XPath est un langage qui a été conçu et développé principalement pour adresser certaines parties d'un document XML. Dans un essai d'injection XPath, nous testons si il est possible d'injecter des données dans une application pour qu'elle exécute des requêtes XPath contrôlées par l'utilisateur. Lorsqu'elle est exploitée avec succès, cette vulnérabilité peut permettre à un attaquant de contourner les mécanismes d'authentification ou d'accéder à des informations sans autorisation.

Les applications Web utilisent fréquemment des bases de données pour stocker et accéder aux données dont elles ont besoin pour leurs opérations. Historiquement, les bases de données relationnelles ont été de loin la technologie la plus commune pour le stockage des données, mais, dans les dernières années, on assiste à une popularité croissante pour les bases de données qui organisent les données en utilisant le langage XML. Tout comme les bases de données relationnelles sont accessibles via le langage SQL, les bases de données XML utiliser XPath comme langage de requête standard. Cependant, d'un point de vue conceptuel, XPath est très similaire à SQL dans son but et ses applications, un résultat intéressant est que les attaques par injection XPath suivent la même logique que les attaques par injection SQL. Dans certains aspects, XPath est encore plus puissant que la norme SQL, car toutes ses cpacités sont déjà présentes dans ses spécifications, alors qu'un grand nombre de techniques qui peuvent être utilisées dans une attaque par injection SQL dépendent des caractéristiques du langage SQL utilisé par la base de données cible. Cela signifie que les attaques par injection XPath peuvent être beaucoup plus souples et omniprésentes. Un autre avantage d'une attaque par injection de XPath est que, contrairement à SQL, aucune ACL sont appliquées, de sorte que notre requête peut accéder à toutes les parties du document XML.

Le modèle d'attaque XPath a d'abord été publié par Amit Klein [1] et est très similaire à l'injection SQL habituelle. Afin d'avoir un premier aperçu du problème, imaginons une page de connexion qui gère l'authentification pour une application dans laquelle l'utilisateur doit saisir son nom d'utilisateur et son mot de passe. Supposons que notre base de données est représentée par le fichier XML suivant:

<?xml version="1.0" encoding="ISO-8859-1"?> 
<users> 
<user> 
<username>gandalf</username> 
<password>!c3</password> 
<account>admin</account> 
</user> 
<user> 
<username>Stefan0</username> 
<password>w1s3c</password> 
<account>guest</account> 
</user> 
<user> 
<username>tony</username> 
<password>Un6R34kb!e</password> 
<account>guest</account> 
</user> 
</users> 

Une requête XPath qui retourne le compte dont le nom d'utilisateur est “Gandalf” et le mot de passe “!c3”serait la suivante :

string(//user[username/text()='gandalf' and password/text()='!c3']/account/text()) 

Si l'application ne filtre pas correctement la saisie par l'utilisateur, le testeur sera en mesure d'injecter du code XPath et d'interférer avec le résultat de la requête. Par exemple, le testeur peut saisir les valeurs suivantes:

Username: ' or '1' = '1 
Password: ' or '1' = '1 

Cela semble très familier, n'est-ce pas? En utilisant ces paramètres, la requête devient:

string(//user[username/text()=// or '1' = '1' and password/text()=// or '1' = '1']/account/text()) 

Comme lors d'une attaque par injection SQL commune, nous avons créé une requête qui renvoie toujours true, ce qui signifie que l'application authentifie l'utilisateur, même si un nom d'utilisateur ou un mot de passe n'ont pas été fournis.

Et comme lors d'une attaque par injection SQL commune, avec l'injection XPath , la première étape consiste à insérer un guillemet simple (') dans le champ à tester, en introduisant une erreur de syntaxe dans la requête, et de vérifier si l'application renvoie un message d'erreur .

S'il n'y a pas de connaissance au sujet des détails de données XML internes et si l'application ne fournit pas de messages d'erreur utile qui nous aident à reconstituer sa logique interne, il est possible d'effectuer une attaque par injection XPath aveugle, dont l'objectif est de reconstruire la structure de données entière. La technique est similaire à l'injection SQL aveuble, car l'approche est d'injecter du code qui crée une requête qui retourne un bit d'information. L'injection XPath aveugle est expliqué plus en détail par Amit Klein dans le document susmentionné.

• Amit Klein: “Blind XPath Injection” - https://www.watchfire.com/securearea/whitepapers.aspx?id=9

  • XPath 1.0 specifications - http://www.w3.org/TR/xpath