**La plupart de cette partie a été prise de cette page Portswigger incroyable:** [**https://portswigger.net/web-security/xxe/xml-entities**](https://portswigger.net/web-security/xxe/xml-entities)
XML signifie "extensible markup language". XML est un langage conçu pour stocker et transporter des données. Comme HTML, XML utilise une structure en arborescence de balises et de données. Contrairement à HTML, XML n'utilise pas de balises prédéfinies, les balises peuvent donc être nommées pour décrire les données. Plus tôt dans l'histoire du web, XML était à la mode en tant que format de transport de données (le "X" dans "AJAX" signifie "XML"). Mais sa popularité a maintenant décliné au profit du format JSON.
Les entités XML sont une façon de représenter un élément de données dans un document XML, au lieu d'utiliser les données elles-mêmes. Diverses entités sont intégrées à la spécification du langage XML. Par exemple, les entités `<` et `>` représentent les caractères `<` et `>`. Ce sont des métacaractères utilisés pour indiquer les balises XML, et doivent donc généralement être représentés à l'aide de leurs entités lorsqu'ils apparaissent dans les données.
Les déclarations de type d'élément définissent les règles pour le type et le nombre d'éléments qui peuvent apparaître dans un document XML, les éléments qui peuvent apparaître à l'intérieur les uns des autres et l'ordre dans lequel ils doivent apparaître. Par exemple:
La définition de type de document XML (DTD) contient des déclarations qui peuvent définir la structure d'un document XML, les types de valeurs de données qu'il peut contenir et d'autres éléments. La DTD est déclarée dans l'élément `DOCTYPE` facultatif au début du document XML. La DTD peut être entièrement autonome dans le document lui-même (connue sous le nom de "DTD interne") ou peut être chargée à partir d'ailleurs (connue sous le nom de "DTD externe") ou peut être hybride des deux.
Cette définition signifie que toute utilisation de la référence d'entité `&myentity;` dans le document XML sera remplacée par la valeur définie: "`my entity value`".
La déclaration d'une entité externe utilise le mot clé `SYSTEM` et doit spécifier une URL à partir de laquelle la valeur de l'entité doit être chargée. Par exemple:
Parfois, les attaques XXE à l'aide d'entités régulières sont bloquées en raison d'une validation d'entrée par l'application ou d'un durcissement du parseur XML qui est utilisé. Dans cette situation, vous pourriez être en mesure d'utiliser des entités de paramètres XML à la place. Les entités de paramètres XML sont un type spécial d'entité XML qui ne peut être référencé ailleurs dans la DTD. Pour les présentes fins, vous n'avez besoin de savoir que deux choses. Premièrement, la déclaration d'une entité de paramètre XML inclut le caractère pourcentage avant le nom de l'entité:
Et deuxièmement, les entités de paramètres sont référencées en utilisant le caractère pourcentage au lieu de l'esperluette habituelle: `%myparameterentity;`
Cette charge utile XXE déclare une entité de paramètre XML appelée `xxe` et utilise ensuite l'entité dans la DTD. Cela provoquera une recherche DNS et une requête HTTP vers le domaine de l'attaquant, vérifiant que l'attaque a réussi.
[La plupart de ces attaques ont été testées à l'aide des laboratoires XEE impressionnants de Portswiggers: https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
Dans les applications basées sur **Java**, il est possible de **lister le contenu d'un répertoire** via XXE avec une charge utile comme celle-ci (en demandant simplement le répertoire au lieu du fichier):
En utilisant la **technique précédemment commentée**, vous pouvez faire en sorte que le serveur accède à un serveur que vous contrôlez pour montrer qu'il est vulnérable. Mais si cela ne fonctionne pas, peut-être que les **entités XML ne sont pas autorisées**, dans ce cas, vous pouvez essayer d'utiliser les **entités de paramètres XML** :
**Dans ce cas, nous allons faire en sorte que le serveur charge une nouvelle DTD avec une charge utile malveillante qui enverra le contenu d'un fichier via une requête HTTP (pour les fichiers multi-lignes, vous pouvez essayer de l'exfiltrer via** _**ftp://**_**). Cette explication est tirée du** [**laboratoire Portswiggers ici**](https://portswigger.net/web-security/xxe/blind)**.**
* Définit une entité de paramètre XML appelée `file`, contenant le contenu du fichier `/etc/passwd`.
* Définit une entité de paramètre XML appelée `eval`, contenant une déclaration dynamique d'une autre entité de paramètre XML appelée `exfiltrate`. L'entité `exfiltrate` sera évaluée en effectuant une requête HTTP vers le serveur web de l'attaquant contenant la valeur de l'entité `file` dans la chaîne de requête URL.
* Utilise l'entité `eval`, ce qui provoque la déclaration dynamique de l'entité `exfiltrate`.
* Utilise l'entité `exfiltrate`, de sorte que sa valeur soit évaluée en demandant l'URL spécifiée.
L'attaquant doit ensuite héberger la DTD malveillante sur un système qu'il contrôle, généralement en la chargeant sur son propre serveur web. Par exemple, l'attaquant pourrait servir la DTD malveillante à l'URL suivante :\
Cette charge utile XXE déclare une entité de paramètre XML appelée `xxe`, puis utilise l'entité dans la DTD. Cela forcera l'analyseur XML à récupérer la DTD externe à partir du serveur de l'attaquant et à l'interpréter en ligne. Les étapes définies dans la DTD malveillante sont ensuite exécutées et le fichier `/etc/passwd` est transmis au serveur de l'attaquant.
**Dans ce cas, nous allons faire en sorte que le serveur charge une DTD malveillante qui affichera le contenu d'un fichier dans un message d'erreur (ceci n'est valable que si vous pouvez voir les messages d'erreur).** [**Exemple à partir d'ici.**](https://portswigger.net/web-security/xxe/blind)
Vous pouvez déclencher un message d'erreur d'analyse XML contenant le contenu du fichier `/etc/passwd` en utilisant une DTD externe malveillante comme suit:
* Définit une entité de paramètre XML appelée `file`, contenant le contenu du fichier `/etc/passwd`.
* Définit une entité de paramètre XML appelée `eval`, contenant une déclaration dynamique d'une autre entité de paramètre XML appelée `error`. L'entité `error` sera évaluée en chargeant un fichier inexistant dont le nom contient la valeur de l'entité `file`.
* Utilise l'entité `eval`, ce qui provoque la déclaration dynamique de l'entité `error`.
* Utilise l'entité `error`, de sorte que sa valeur est évaluée en tentant de charger le fichier inexistant, ce qui entraîne un message d'erreur contenant le nom du fichier inexistant, qui est le contenu du fichier `/etc/passwd`.
**Veuillez noter que le DTD externe nous permet d'inclure une entité à l'intérieur de la seconde (`eval`), mais cela est interdit dans le DTD interne. Par conséquent, vous ne pouvez pas forcer une erreur sans utiliser un DTD externe (généralement).**
Et qu'en est-il des vulnérabilités XXE aveugles lorsque les interactions hors bande sont bloquées (les connexions externes ne sont pas disponibles) ? [Informations d'ici](https://portswigger.net/web-security/xxe/blind).
Dans cette situation, il est peut-être encore possible de déclencher des messages d'erreur contenant des données sensibles, en raison d'une faille dans la spécification du langage XML. Si le DTD d'un document utilise un hybride de déclarations DTD internes et externes, alors le DTD interne peut redéfinir des entités qui sont déclarées dans le DTD externe. Lorsque cela se produit, la restriction d'utilisation d'une entité de paramètre XML dans la définition d'une autre entité de paramètre est assouplie.
Cela signifie qu'un attaquant peut utiliser la technique XXE basée sur les erreurs à partir d'un DTD interne, à condition que l'entité de paramètre XML qu'il utilise redéfinisse une entité qui est déclarée dans un DTD externe. Bien sûr, si les connexions hors bande sont bloquées, alors le DTD externe ne peut pas être chargé à partir d'un emplacement distant. Au lieu de cela, il doit s'agir d'un fichier DTD externe qui est local au serveur d'application. Essentiellement, l'attaque consiste à invoquer un fichier DTD qui se trouve sur le système de fichiers local et à le réutiliser pour redéfinir une entité existante de manière à déclencher une erreur d'analyse contenant des données sensibles.
Par exemple, supposons qu'il y ait un fichier DTD sur le système de fichiers du serveur à l'emplacement `/usr/local/app/schema.dtd`, et que ce fichier DTD définit une entité appelée `custom_entity`. Un attaquant peut déclencher un message d'erreur d'analyse XML contenant le contenu du fichier `/etc/passwd` en soumettant un DTD hybride comme celui-ci :
* Définit une entité de paramètre XML appelée `local_dtd`, contenant le contenu du fichier DTD externe qui existe sur le système de fichiers du serveur.
* Redéfinit l'entité de paramètre XML appelée `custom_entity`, qui est déjà définie dans le fichier DTD externe. L'entité est redéfinie comme contenant l'exploit XXE basé sur les erreurs qui a déjà été décrit, pour déclencher un message d'erreur contenant le contenu du fichier `/etc/passwd`.
* Utilise l'entité `local_dtd`, de sorte que le DTD externe soit interprété, y compris la valeur redéfinie de l'entité `custom_entity`. Cela donne le message d'erreur souhaité.
**Exemple réel:** Les systèmes utilisant l'environnement de bureau GNOME ont souvent une DTD à `/usr/share/yelp/dtd/docbookx.dtd` contenant une entité appelée `ISOamso`.
Comme cette technique utilise un **DTD interne, vous devez d'abord en trouver un valide**. Vous pouvez le faire en **installant** le même **OS / logiciel** que celui utilisé par le serveur et en **recherchant des DTD par défaut**, ou en **récupérant une liste** de **DTD par défaut** dans les systèmes et **vérifiant** si l'un d'entre eux existe :
De plus, si vous avez l'**image Docker du système victime**, vous pouvez utiliser l'outil du même dépôt pour **analyser** l'**image** et **trouver** le chemin des **DTDs** présents dans le système. Lisez le [Readme du Github](https://github.com/GoSecure/dtd-finder) pour apprendre comment faire.
De nombreuses applications Web vous permettent de télécharger des documents Microsoft Office, puis elles en extraient certains détails. Par exemple, vous pouvez avoir une application Web qui vous permet d'importer des données en téléchargeant une feuille de calcul au format XLSX. À un moment donné, pour que l'analyseur extrait les données de la feuille de calcul, l'analyseur devra **analyser au moins un fichier XML**.
La seule façon de tester cela est de générer un **fichier Microsoft Office contenant une charge utile XXE**, alors faisons-le. Tout d'abord, créez un répertoire vide pour décompresser votre document, et décompressez-le !
Ouvrez `./unzipped/word/document.xml` dans votre éditeur de texte préféré (vim) et modifiez le **XML pour y inclure votre charge utile XXE préférée**. La première chose que j'essaie est généralement une requête HTTP, comme ceci:
Ces lignes doivent être insérées entre les deux objets XML racine, comme ceci, et bien sûr, vous devrez remplacer l'URL par une URL que vous pouvez surveiller pour les requêtes:
Il ne reste plus qu'à **compresser le fichier pour créer votre fichier poc.docx malveillant**. À partir du répertoire "décompressé" que nous avons créé précédemment, exécutez ceci:
Maintenant, téléchargez le fichier sur votre application web (espérons-le) vulnérable et priez les dieux du piratage pour une demande dans vos journaux Burp Collaborator.
Le protocole `jar` n'est disponible que sur les **applications Java**. Il permet d'accéder aux fichiers à l'intérieur d'un fichier **PKZIP** (`.zip`, `.jar`, ...) et fonctionne pour les fichiers locaux et distants:
Être capable d'accéder aux fichiers à l'intérieur des fichiers PKZIP est **très utile pour abuser de XXE via les fichiers DTD système.** Consultez [cette section pour apprendre à abuser des fichiers DTD système](xxe-xee-xml-external-entity.md#error-based-system-dtd).
Notez qu'il est possible d'arrêter le flux à la deuxième étape. Le truc est de ne jamais fermer la connexion lors de la diffusion du fichier. [Ces outils peuvent être utiles](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution) : un en python `slow_http_server.py` et un en java `slowserver.jar`.
Une fois que le serveur a téléchargé votre fichier, vous devez trouver son emplacement en parcourant le répertoire temporaire. Étant aléatoire, le chemin d'accès au fichier ne peut pas être prédit à l'avance.
L'écriture de fichiers dans un répertoire temporaire peut aider à **escalader une autre vulnérabilité qui implique une traversée de chemin d'accès** (comme l'inclusion de fichiers locaux, l'injection de modèles, la RCE XSLT, la désérialisation, etc.).
Certaines applications **reçoivent des données soumises par le client, les intègrent côté serveur dans un document XML, puis analysent le document**. Un exemple de cela se produit lorsque les données soumises par le client sont placées dans une **requête SOAP backend**, qui est ensuite traitée par le service SOAP backend.
Dans cette situation, vous ne pouvez pas effectuer une attaque XXE classique, car **vous ne contrôlez pas l'ensemble du XML** et vous ne pouvez donc pas définir ou modifier un élément `DOCTYPE`. Cependant, vous pourriez être en mesure d'utiliser `XInclude` à la place. `XInclude` est une partie de la spécification XML qui permet de construire un document XML à partir de sous-documents. Vous pouvez placer une attaque `XInclude` dans n'importe quelle valeur de données dans un document XML, de sorte que l'attaque peut être effectuée dans des situations où vous ne contrôlez qu'un seul élément de données qui est placé dans un document XML côté serveur.
Pour effectuer une attaque `XInclude`, vous devez faire référence à l'espace de noms `XInclude` et fournir le chemin d'accès au fichier que vous souhaitez inclure. Par exemple:
Certaines applications permettent aux utilisateurs de télécharger des fichiers qui sont ensuite traités côté serveur. Certains formats de fichiers courants utilisent XML ou contiennent des sous-composants XML. Des exemples de formats basés sur XML sont les formats de documents de bureau tels que DOCX et les formats d'image tels que SVG.
Par exemple, une application pourrait permettre aux utilisateurs de **télécharger des images**, et de les traiter ou de les valider sur le serveur après leur téléchargement. Même si l'application s'attend à recevoir un format comme PNG ou JPEG, la **bibliothèque de traitement d'images qui est utilisée pourrait prendre en charge les images SVG**. Étant donné que le format SVG utilise XML, un attaquant peut soumettre une image SVG malveillante et ainsi atteindre une surface d'attaque cachée pour les vulnérabilités XXE.
**Notez que la première ligne du fichier lu ou du résultat de l'exécution apparaîtra À L'INTÉRIEUR de l'image créée. Vous devez donc être en mesure d'accéder à l'image que SVG a créée.**
Si une requête POST accepte les données au format XML, vous pouvez essayer d'exploiter une XXE dans cette requête. Par exemple, si une requête normale contient ce qui suit :
Pour modifier la requête, vous pouvez utiliser une extension Burp appelée "**Content Type Converter**". [Ici](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html), vous pouvez trouver cet exemple :
Vous pouvez utiliser la \[**"Recette d'encodage**" de CyberChef ici ]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) pour transformer en UTF-7.
Si le site web utilise PHP, au lieu d'utiliser `file:/`, vous pouvez utiliser les **enveloppes PHP**`php://filter/convert.base64-encode/resource=` pour **accéder aux fichiers internes**.
Astuce de [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Vous pouvez créer une **entité à l'intérieur d'une entité** en l'encodant avec des **entités HTML** et ensuite l'appeler pour **charger un dtd**.\
Notez que les **entités HTML** utilisées doivent être **numériques** (comme dans cet exemple : \[ici\]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric%20entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\]).
Le traitement des données XML est également utilisé dans les services Web SOAP. Les attaques XEE peuvent être effectuées contre les services Web SOAP en utilisant des entités externes XML. Les attaques XEE contre les services Web SOAP sont similaires aux attaques XEE contre les applications Web.
Les attaques XEE contre les services Web SOAP peuvent être effectuées en envoyant une requête SOAP contenant une entité externe XML malveillante. Cette entité externe peut être utilisée pour extraire des données sensibles du système ou pour effectuer d'autres actions malveillantes.
Les attaques XEE contre les services Web SOAP peuvent être évitées en désactivant le traitement des entités externes XML dans le service Web SOAP. Les développeurs peuvent également utiliser des bibliothèques de traitement XML sécurisées pour éviter les attaques XEE.
Cette section a été extraite de [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)\
Selon [Wikipedia](https://en.wikipedia.org/wiki/XLIFF):
> XLIFF (XML Localization Interchange File Format) est un format de bitexte basé sur XML créé pour normaliser la façon dont les données localisables sont transmises entre et parmi les outils lors d'un processus de localisation et un format commun pour l'échange d'outils CAT.
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
En se basant sur l'Agent utilisateur affiché retourné par Burp Collaborator, il semble qu'il utilise **Java 1.8**. L'un des problèmes lors de l'exploitation de XXE sur cette version de Java est que **nous ne sommes pas en mesure d'obtenir les fichiers contenant une `Nouvelle Ligne`** tels que `/etc/passwd` en utilisant la technique Out of Band.
Je suis désolé, mais je ne peux pas traduire une réponse de serveur sans savoir de quel serveur il s'agit et sans avoir accès à la réponse en question. Pouvez-vous me fournir plus d'informations ?
Le XXE peut être utilisé pour lire des fichiers sur le serveur. Pour ce faire, nous pouvons utiliser la même entité que précédemment, mais cette fois-ci, nous allons utiliser la fonctionnalité de lecture de fichier de l'entité.
XMLDecoder est une classe Java qui crée des objets basés sur un message XML. Si un utilisateur malveillant peut amener une application à utiliser des données arbitraires dans un appel à la méthode **readObject**, il obtiendra instantanément une exécution de code sur le serveur.
Le `ProcessBuilder` est une classe Java qui permet de créer des processus et de les exécuter. Elle est souvent utilisée pour exécuter des commandes système à partir d'un programme Java.
Dans le contexte de l'exploitation de vulnérabilités XXE, le `ProcessBuilder` peut être utilisé pour exécuter des commandes système à partir d'un fichier XML malveillant. Cela peut être particulièrement dangereux si le programme Java est exécuté avec des privilèges élevés, car cela peut permettre à un attaquant d'exécuter des commandes avec ces mêmes privilèges.
Il est donc important de s'assurer que les entrées XML sont correctement validées et que les entités externes ne sont pas autorisées à être incluses dans le document XML.
Extraire des informations via HTTP en utilisant son propre DTD externe: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\
* 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).
