## XSS DOM
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
* 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 [**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** 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).
## **Vulnérabilités DOM**
> **Sources**
>
> Une source est une propriété JavaScript qui accepte des données potentiellement contrôlées par un attaquant. Un exemple de source est la propriété `location.search` car elle lit l'entrée de la chaîne de requête, qui est relativement simple à contrôler pour un attaquant. En fin de compte, toute propriété qui peut être contrôlée par l'attaquant est une source potentielle. Cela inclut l'URL de référence (exposée par la chaîne `document.referrer`), les cookies de l'utilisateur (exposés par la chaîne `document.cookie`) et les messages Web.
> **Sinks**
>
> Un sink est une fonction JavaScript potentiellement dangereuse ou un objet DOM qui peut causer des effets indésirables si des données contrôlées par un attaquant lui sont transmises. Par exemple, la fonction `eval()` est un sink car elle traite l'argument qui lui est passé en tant que JavaScript. Un exemple de sink HTML est `document.body.innerHTML` car il permet potentiellement à un attaquant d'injecter du HTML malveillant et d'exécuter du JavaScript arbitraire.
Fondamentalement, les vulnérabilités basées sur le DOM surviennent lorsqu'un site Web **transmet des données d'une source à un sink**, qui traite ensuite les données de manière non sécurisée dans le contexte de la session du client.
{% hint style="info" %}
**Vous pouvez trouver une liste plus mise à jour des sources et des sinks dans** [**https://github.com/wisec/domxsswiki/wiki**](https://github.com/wisec/domxsswiki/wiki)
{% endhint %}
**Sources courantes :**
```javascript
document.URL
document.documentURI
document.URLUnencoded
document.baseURI
location
document.cookie
document.referrer
window.name
history.pushState
history.replaceState
localStorage
sessionStorage
IndexedDB (mozIndexedDB, webkitIndexedDB, msIndexedDB)
Database
```
**Sources courantes :**
| [**Redirection ouverte**](dom-xss.md#open-redirect) | [**Injection de Javascript**](dom-xss.md#javascript-injection) | [**Manipulation de données DOM**](dom-xss.md#dom-data-manipulation) | **jQuery** |
| -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
| `location` | `eval()` | `scriptElement.src` | `add()` |
| `location.host` | `Function() constructor` | `scriptElement.text` | `after()` |
| `location.hostname` | `setTimeout()` | `scriptElement.textContent` | `append()` |
| `location.href` | `setInterval()` | `scriptElement.innerText` | `animate()` |
| `location.pathname` | `setImmediate()` | `someDOMElement.setAttribute()` | `insertAfter()` |
| `location.search` | `execCommand()` | `someDOMElement.search` | `insertBefore()` |
| `location.protocol` | `execScript()` | `someDOMElement.text` | `before()` |
| `location.assign()` | `msSetImmediate()` | `someDOMElement.textContent` | `html()` |
| `location.replace()` | `range.createContextualFragment()` | `someDOMElement.innerText` | `prepend()` |
| `open()` | `crypto.generateCRMFRequest()` | `someDOMElement.outerText` | `replaceAll()` |
| `domElem.srcdoc` | **\`\`**[**Manipulation de chemin de fichier local**](dom-xss.md#local-file-path-manipulation) | `someDOMElement.value` | `replaceWith()` |
| `XMLHttpRequest.open()` | `FileReader.readAsArrayBuffer()` | `someDOMElement.name` | `wrap()` |
| `XMLHttpRequest.send()` | `FileReader.readAsBinaryString()` | `someDOMElement.target` | `wrapInner()` |
| `jQuery.ajax()` | `FileReader.readAsDataURL()` | `someDOMElement.method` | `wrapAll()` |
| `$.ajax()` | `FileReader.readAsText()` | `someDOMElement.type` | `has()` |
| **\`\`**[**Manipulation de requête Ajax**](dom-xss.md#ajax-request-manipulation) | `FileReader.readAsFile()` | `someDOMElement.backgroundImage` | `constructor()` |
| `XMLHttpRequest.setRequestHeader()` | `FileReader.root.getFile()` | `someDOMElement.cssText` | `init()` |
| `XMLHttpRequest.open()` | `FileReader.root.getFile()` | `someDOMElement.codebase` | `index()` |
| `XMLHttpRequest.send()` | [**Manipulation de lien**](dom-xss.md#link-manipulation) | `someDOMElement.innerHTML` | `jQuery.parseHTML()` |
| `jQuery.globalEval()` | `someDOMElement.href` | `someDOMElement.outerHTML` | `$.parseHTML()` |
| `$.globalEval()` | `someDOMElement.src` | `someDOMElement.insertAdjacentHTML` | [**Injection de JSON côté client**](dom-xss.md#client-side-sql-injection) |
| **\`\`**[**Manipulation de stockage HTML5**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action` | `someDOMElement.onevent` | `JSON.parse()` |
| `sessionStorage.setItem()` | [**Injection XPath**](dom-xss.md#xpath-injection) | `document.write()` | `jQuery.parseJSON()` |
| `localStorage.setItem()` | `document.evaluate()` | `document.writeln()` | `$.parseJSON()` |
| **``**[**`Déni de service`**](dom-xss.md#denial-of-service)**``** | `someDOMElement.evaluate()` | `document.title` | **\`\`**[**Manipulation de cookie**](dom-xss.md#cookie-manipulation) |
| `requestFileSystem()` | **\`\`**[**Manipulation de domaine de document**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()` | `document.cookie` |
| `RegExp()` | `document.domain` | `history.pushState()` | [**Empoisonnement d'URL WebSocket**](dom-xss.md#websocket-url-poisoning) |
| [**Injection SQL côté client**](dom-xss.md#client-side-sql-injection) | [**Manipulation de message Web**](dom-xss.md#web-message-manipulation) | `history.replaceState()` | `WebSocket` |
| `executeSql()` | `postMessage()` | \`\` | \`\` |
Le puits **`innerHTML`** n'accepte pas les éléments `script` sur les navigateurs modernes, ni les événements `svg onload`. Cela signifie que vous devrez utiliser des éléments alternatifs tels que `img` ou `iframe`.
Ce type de XSS est probablement le **plus difficile à trouver**, car vous devez regarder à l'intérieur du code JS, voir s'il **utilise** un objet dont vous contrôlez la **valeur**, et dans ce cas, voir s'il y a **un moyen de l'exploiter** pour exécuter du JS arbitraire.
## Outils pour les trouver
* [https://github.com/mozilla/eslint-plugin-no-unsanitized](https://github.com/mozilla/eslint-plugin-no-unsanitized)
## Exemples
### Redirection ouverte
De : [https://portswigger.net/web-security/dom-based/open-redirection](https://portswigger.net/web-security/dom-based/open-redirection)
#### Comment
Les vulnérabilités de redirection ouverte basées sur le DOM surviennent lorsqu'un script écrit des données **contrôlables par l'attaquant** dans un **puits** qui peut déclencher une **navigation entre domaines**.
Rappelez-vous que **si vous pouvez démarrer l'URL** où la victime va être **redirigée**, vous pouvez exécuter du **code arbitraire** comme : **`javascript:alert(1)`**
#### Puits
```
location
location.host
location.hostname
location.href
location.pathname
location.search
location.protocol
location.assign()
location.replace()
open()
domElem.srcdoc
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.ajax()
$.ajax()
```
### Manipulation de cookies
De: [https://portswigger.net/web-security/dom-based/cookie-manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation)
#### Comment
Les vulnérabilités de manipulation de cookies basées sur le DOM surviennent lorsqu'un script écrit des données contrôlées par l'attaquant dans la valeur d'un cookie.\
Cela peut être abusé pour faire en sorte que la page se comporte de manière inattendue (si le cookie est utilisé sur le web) ou pour effectuer une attaque de fixation de session (si le cookie est utilisé pour suivre la session de l'utilisateur).
#### Sources
```
document.cookie
```
### Injection de JavaScript
De: [https://portswigger.net/web-security/dom-based/javascript-injection](https://portswigger.net/web-security/dom-based/javascript-injection)
#### Comment
Les vulnérabilités d'injection de JavaScript basées sur le DOM se produisent lorsqu'un script exécute des données contrôlées par l'attaquant en tant que JavaScript.
#### Cibles
```
eval()
Function() constructor
setTimeout()
setInterval()
setImmediate()
execCommand()
execScript()
msSetImmediate()
range.createContextualFragment()
crypto.generateCRMFRequest()
```
### Manipulation de document-domain
De: [https://portswigger.net/web-security/dom-based/document-domain-manipulation](https://portswigger.net/web-security/dom-based/document-domain-manipulation)
#### Comment
Les vulnérabilités de manipulation de document-domain surviennent lorsqu'un script utilise des données contrôlées par l'attaquant pour définir la propriété `document.domain`.
La propriété `document.domain` est utilisée par les navigateurs dans leur application de la politique de même origine. Si deux pages de différentes origines définissent explicitement la même valeur de `document.domain`, alors ces deux pages peuvent interagir de manière non restreinte.\
Les navigateurs imposent généralement certaines restrictions sur les valeurs qui peuvent être attribuées à `document.domain`, et peuvent empêcher l'utilisation de valeurs complètement différentes de l'origine réelle de la page. Mais cela ne se produit pas toujours et ils permettent généralement d'utiliser des domaines enfants ou parents.
#### Sinks
```
document.domain
```
### Empoisonnement d'URL WebSocket
De: [https://portswigger.net/web-security/dom-based/websocket-url-poisoning](https://portswigger.net/web-security/dom-based/websocket-url-poisoning)
#### Comment
L'empoisonnement d'URL WebSocket se produit lorsqu'un script utilise des données contrôlables comme URL cible d'une connexion WebSocket.
#### Sources
Le constructeur `WebSocket` peut conduire à des vulnérabilités d'empoisonnement d'URL WebSocket.
### Manipulation de lien
De: [https://portswigger.net/web-security/dom-based/link-manipulation](https://portswigger.net/web-security/dom-based/link-manipulation)
#### Comment
Les vulnérabilités de manipulation de lien basées sur le DOM se produisent lorsqu'un script écrit des données contrôlables par l'attaquant vers une cible de navigation dans la page actuelle, telle qu'un lien cliquable ou l'URL de soumission d'un formulaire.
#### Sources
```
someDOMElement.href
someDOMElement.src
someDOMElement.action
```
### Manipulation de requête Ajax
De: [https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation](https://portswigger.net/web-security/dom-based/ajax-request-header-manipulation)
#### Comment
Les vulnérabilités de manipulation de requête Ajax surviennent lorsqu'un script écrit des données contrôlées par l'attaquant dans une requête Ajax qui est émise à l'aide d'un objet `XmlHttpRequest`.
#### Sinks
```
XMLHttpRequest.setRequestHeader()
XMLHttpRequest.open()
XMLHttpRequest.send()
jQuery.globalEval()
$.globalEval()
```
### Manipulation de chemin de fichier local
De: [https://portswigger.net/web-security/dom-based/local-file-path-manipulation](https://portswigger.net/web-security/dom-based/local-file-path-manipulation)
#### Comment
Les vulnérabilités de manipulation de chemin de fichier local surviennent lorsqu'un script transmet des données contrôlées par l'attaquant à une API de gestion de fichiers en tant que paramètre `filename`. Un attaquant peut utiliser cette vulnérabilité pour construire une URL qui, si elle est visitée par un autre utilisateur, **forcera le navigateur de l'utilisateur à ouvrir/écrire un fichier local arbitraire**.
#### Sources
```
FileReader.readAsArrayBuffer()
FileReader.readAsBinaryString()
FileReader.readAsDataURL()
FileReader.readAsText()
FileReader.readAsFile()
FileReader.root.getFile()
FileReader.root.getFile()
```
### Injection SQL côté client
De: [https://portswigger.net/web-security/dom-based/client-side-sql-injection](https://portswigger.net/web-security/dom-based/client-side-sql-injection)
#### Comment
Les vulnérabilités d'injection SQL côté client surviennent lorsqu'un script incorpore des données contrôlées par l'attaquant dans une requête SQL côté client de manière non sécurisée.
#### Cibles
```
executeSql()
```
### Manipulation de stockage HTML5
De: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](https://portswigger.net/web-security/dom-based/html5-storage-manipulation)
#### Comment
Les vulnérabilités de manipulation de stockage HTML5 surviennent lorsqu'un script **stocke des données contrôlées par l'attaquant dans le stockage HTML5** du navigateur web (soit `localStorage` soit `sessionStorage`).\
Ce **comportement ne constitue pas en soi une vulnérabilité de sécurité**. Cependant, si l'application **lit ultérieurement les données stockées et les traite de manière non sécurisée**, un attaquant peut exploiter le mécanisme de stockage pour délivrer d'autres attaques basées sur le DOM, telles que l'injection de script et la faille XSS (cross-site scripting).
#### Sinks
```
sessionStorage.setItem()
localStorage.setItem()
```
### Injection XPath
De: [https://portswigger.net/web-security/dom-based/client-side-xpath-injection](https://portswigger.net/web-security/dom-based/client-side-xpath-injection)
#### Comment
Les vulnérabilités d'injection XPath basées sur le DOM se produisent lorsqu'un script incorpore des données contrôlées par l'attaquant dans une requête XPath.
#### Cibles
```
document.evaluate()
someDOMElement.evaluate()
```
### Injection JSON côté client
De: [https://portswigger.net/web-security/dom-based/client-side-json-injection](https://portswigger.net/web-security/dom-based/client-side-json-injection)
#### Comment
Les vulnérabilités d'injection JSON basées sur le DOM se produisent lorsqu'un script incorpore des données contrôlées par l'attaquant dans une chaîne qui est analysée en tant que structure de données JSON, puis traitée par l'application.
#### Cibles
```
JSON.parse()
jQuery.parseJSON()
$.parseJSON()
```
### Manipulation de messages Web
De: [https://portswigger.net/web-security/dom-based/web-message-manipulation](https://portswigger.net/web-security/dom-based/web-message-manipulation)
#### Comment
Les vulnérabilités de messages Web se produisent lorsqu'un script envoie des données contrôlées par un attaquant en tant que message Web à un autre document dans le navigateur.\
**Exemple** de manipulation de messages Web vulnérables dans [https://portswigger.net/web-security/dom-based/controlling-the-web-message-source](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source)
#### Sources
La méthode `postMessage()` pour l'envoi de messages Web peut entraîner des vulnérabilités si l'écouteur d'événements pour la réception de messages gère les données entrantes de manière non sécurisée.
### Manipulation de données DOM
De: [https://portswigger.net/web-security/dom-based/dom-data-manipulation](https://portswigger.net/web-security/dom-based/dom-data-manipulation)
#### Comment
Les vulnérabilités de manipulation de données DOM se produisent lorsqu'un script écrit des données contrôlées par un attaquant dans un champ du DOM qui est utilisé dans l'interface utilisateur visible ou la logique côté client. Un attaquant peut utiliser cette vulnérabilité pour construire une URL qui, si elle est visitée par un autre utilisateur, modifiera l'apparence ou le comportement de l'interface utilisateur côté client.
#### Sources
```
scriptElement.src
scriptElement.text
scriptElement.textContent
scriptElement.innerText
someDOMElement.setAttribute()
someDOMElement.search
someDOMElement.text
someDOMElement.textContent
someDOMElement.innerText
someDOMElement.outerText
someDOMElement.value
someDOMElement.name
someDOMElement.target
someDOMElement.method
someDOMElement.type
someDOMElement.backgroundImage
someDOMElement.cssText
someDOMElement.codebase
document.title
document.implementation.createHTMLDocument()
history.pushState()
history.replaceState()
```
### Déni de service
De: [https://portswigger.net/web-security/dom-based/denial-of-service](https://portswigger.net/web-security/dom-based/denial-of-service)
#### Comment
Les vulnérabilités de déni de service basées sur le DOM surviennent lorsqu'un script transmet des données contrôlées par l'attaquant de manière non sécurisée à une API de plateforme problématique, telle qu'une API dont l'invocation peut amener l'ordinateur de l'utilisateur à consommer des quantités excessives de CPU ou d'espace disque. Cela peut entraîner des effets secondaires si le navigateur restreint la fonctionnalité du site Web, par exemple en rejetant les tentatives de stockage de données dans `localStorage` ou en tuant les scripts occupés.
#### Sinks
```
requestFileSystem()
RegExp()
```
## Dom Clobbering
{% content-ref url="dom-clobbering.md" %}
[dom-clobbering.md](dom-clobbering.md)
{% endcontent-ref %}
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
* 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** 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).