Modules de traitement XML
*************************

**Code source:** Lib/xml/

======================================================================

Les interfaces de Python de traitement de XML sont regroupées dans le
paquet "xml".

Avertissement:

  Les modules XML ne sont pas protégés contre les données mal
  construites ou malicieuses. Si vous devez parcourir des données
  douteuses non authentifiées voir les sections Vulnérabilités XML et
  Le paquet defusedxml.

Il est important de noter que les modules dans le paquet "xml"
nécessitent qu'au moins un analyseur compatible SAX soit disponible.
L'analyseur Expat est inclus dans Python, ainsi le module
"xml.parsers.expat" est toujours disponible.

La documentation des *bindings* des interfaces DOM et SAX  se trouve
dans "xml.dom" et "xml.sax".

Les sous-modules de traitement XML sont :

* "xml.etree.ElementTree": l'API ElementTree, un processeur simple et
  léger

* "xml.dom": la définition de l'API DOM

* "xml.dom.minidom": une implémentation minimale de DOM

* "xml.dom.pulldom": gestion de la construction partiel des arbres DOM

* "xml.sax": classes de bases SAX2 base et fonctions utilitaires

* "xml.parsers.expat": le *binding* de l'analyseur Expat


Vulnérabilités XML
==================

Les modules de traitement XML ne sont pas sécurisés contre les données
construite malicieusement. Un attaquant peut abuser des
fonctionnalités XML pour exécuter des attaques par déni de service,
accéder des fichiers locaux, générer des connexions réseaux à d'autres
machines ou contourner des pare-feux.

Le tableau suivant donne une vue d'ensemble des attaques connues et
indique si les différents modules y sont vulnérables.

+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| type                      | sax                | etree              | minidom            | pulldom            | xmlrpc             |
|===========================|====================|====================|====================|====================|====================|
| *billion laughs*          | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) |
+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| *quadratic blowup*        | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) | **Vulnerable** (1) |
+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| *external entity          | Safe (5)           | Safe (2)           | Safe (3)           | Safe (5)           | Sûr (4)            |
| expansion*                |                    |                    |                    |                    |                    |
+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| Récupération de DTD       | Safe (5)           | Sûr                | Sûr                | Safe (5)           | Sûr                |
+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
| *decompression bomb*      | Sûr                | Sûr                | Sûr                | Sûr                | **Vulnérable**     |
+---------------------------+--------------------+--------------------+--------------------+--------------------+--------------------+

1. Expat 2.4.1 and newer is not vulnerable to the "billion laughs" and
   "quadratic blowup" vulnerabilities. Items still listed as
   vulnerable due to potential reliance on system-provided libraries.
   Check "pyexpat.EXPAT_VERSION".

2. "xml.etree.ElementTree" n'étend pas les entités externes et lève
   une exception "ParserError" quand une telle entité est rencontrée.

3. "xml.dom.minidom" n'étend pas les entités externe et renvoie
   simplement le verbatim de l'entité non étendu.

4. "xmlrpclib" n'étend pas les entités externes et les omet.

5. Depuis Python 3.7.1, les entités générales externes ne sont plus
   traitées par défaut depuis Python.

*billion laughs* / *exponential entity expansion*
   L'attaque Billion Laughs -- aussi connue comme *exponential entity
   expansion* -- utilise de multiples niveaux d'entités imbriquées.
   Chaque entité se réfère à une autre entité de multiple fois.
   L'entité finale contiens une chaîne courte. Le résultat de
   l'expansion exponentielle génère plusieurs gigaoctet de texte et
   consomme beaucoup de mémoire et de temps processeur.

*quadratic blowup entity expansion*
   Une attaque *quadratic blowup* est similaire à l'attaque Billion
   Laughs ; il s'agit également d'un abus d'extension d'entités. Au
   lieu d'utiliser des entités imbriquées, cette attaque répète encore
   et encore une seule entité de plusieurs milliers de caractères.
   Cette attaque n'est pas aussi efficace que la version exponentielle
   mais contourne les contre-mesures de l'analyseur qui interdit les
   entités imbriquées de multiples fois.

*external entity expansion*
   Les déclarations d'entités peuvent contenir plus que du texte de
   substitution. Elles peuvent également référencer des ressources
   externes ou des fichiers locaux. L'analyseur XML accède à ces
   fichiers et inclut les contenus dans le document XML.

Récupération de DTD
   Certaines bibliothèques XML comme "xml.dom.pulldom" de Python
   récupère les documents de définitions de types (DTD) depuis des
   emplacements distants ou locaux. La fonctionnalité a des
   implications similaires que le problème d'extension d'entités
   externes.

*decompression bomb*
   Des bombes de décompression (ou ZIP bomb) sont valables pour toutes
   les bibliothèques XML qui peuvent analyser des flux XML compressés
   comme des flux HTTP *gzip* ou des fichiers compressés *LZMA*. Pour
   L'attaquant, cela permet de réduire d'une magnitude d'ordre 3 ou
   plus la quantité de données transmises.

La documentation de defusedxml sur PyPI contient plus d'informations
sur tous les vecteurs d'attaques connus ainsi que des exemples et des
références.


Le paquet "defusedxml"
======================

defusedxml  est un paquet écrit exclusivement en Python avec des sous-
classe modifiées  de tous les analyseurs de la *stdlib* XML qui
empêche toutes opérations potentiellement malicieuses. L'utilisation
de ce paquet est recommandé pour tous serveurs qui analyseraient des
donnés XML non fiables. Le paquet inclut également des exemples
d'attaques et une documentation plus fournie sur plus d'attaques XML
comme *XPath injection*.
