Comment prévenir les attaques par injection XPath

Les applications web sont vulnérables à plusieurs types d’attaques, mais elles sont particulièrement exposées aux attaques par injection de code. L’une d’elles, l’injection XPath, exploite les sites qui demandent des informations aux utilisateurs pour accéder à des données stockées au format XML. Tous les sites utilisant une base de données au format XML peuvent être vulnérables à cette attaque.

XPath est une syntaxe de requête que les sites web peuvent utiliser pour rechercher des données dans leurs magasins XML. Correctement exécutées, les requêtes XPath permettent légitimement de localiser les données contenues dans des éléments et des attributs. Les sites utilisant des bases de données contenant des données au format XML intègrent les données saisies par l’utilisateur (par exemple, un nom d’utilisateur et un mot de passe) dans des requêtes XPath afin de trouver les données requises.

Cependant, comme pour les autres attaques par injection (notamment la célèbre injection SQL), un acteur malveillant peut exploiter ce processus en fournissant des informations malformées. Un attaquant peut découvrir la structure des données XML et accéder à des données auxquelles il ne devrait normalement pas avoir accès. Les attaquants qui obtiennent ces informations peuvent élever leurs privilèges d’accès (une attaque par « élévation de privilèges »), ce qui peut compromettre l’application et les données sensibles, puis leur permettre d’attaquer le reste de l’organisation.

Au-delà de la suppression ou de la corruption des données, leur exfiltration peut permettre aux pirates d’exécuter des commandes sur l’application, d’ouvrir la voie à d’autres attaques contre le serveur et de mettre toute l’organisation à mal par d’autres attaques. Les conséquences de ces attaques peuvent nuire à la réputation de nos applications et à la crédibilité de l’entreprise auprès de ses clients, voire les détruire.

Heureusement, nous pouvons protéger nos sites contre les attaques par injection XPath. Dans cet article, nous explorons les vulnérabilités XML et découvrons comment éviter qu’elles ne compromettent les données des applications.

Repérer et corriger les vulnérabilités d’injection XPath

Pour découvrir comment prévenir les injections XPath, nous allons en examiner une. Nous verrons ensuite comment protéger au mieux nos applications et nos données contre cette attaque.

Exemple d’application d’authentification vulnérable

Prenons l’exemple d’une application qui demande aux utilisateurs de se connecter avec un nom d’utilisateur et un mot de passe.

Créez un dossier nommé xpath, puis, dans ce dossier, créez un fichier nommé users_info.xml contenant les données XML ci-dessous :

1<users>
2
3  <userinfo>
4    <user_id>1</user_id>
5    <username>jennifer</username>
6    <password>4uyFh6v0</password>
7    <account_no>757456</account_no>
8  </userinfo>
9
10  <userinfo>
11    <user_id>2</user_id>
12    <username>kimkimani</username>
13    <password>6wreD1678</password>
14    <account_no>870965</account_no>
15  </userinfo>
16
17  <userinfo>
18    <user_id>3</user_id>
19    <username>michael</username>
20    <password>gf5dG63g</password>
21    <account_no>345689</account_no>
22  </userinfo>
23
24  <userinfo>
25    <user_id>4</user_id>
26    <username>robert</username>
27    <password>yH8wej3h</password>
28    <account_no>096417</account_no>
29  </userinfo>
30
31</users>

Dans le dossier 0xpath, créez un fichier, nommez-le main.py, puis collez le code suivant dans ce fichier :

1# Import the required modules
2from lxml import etree
3
4# Parse the XML data
5tree = etree.parse("users_info.xml")
6
7def login(username, password):
8	expression = "/users/userinfo[username='" + username + "' and password='" + password + "']"
9
10	results = tree.xpath(expression)
11
12	# if no results, which means login details did not match
13	if len(results) < 1:
14    		print("Incorrect credentials! Check your username or password.")
15
16	# if login details match
17	else:
18    	for result in results:
19        	print(f'Login successful! username: {result[1].text}, password: {result[2].text}') 
20# Get the user-provided input
21username = input("Enter your username: ")
22password = input("Enter your password: ")
23
24login(username, password)

Le code charge les données XML, puis exécute une requête XPath pour sélectionner les données XML correspondant aux identifiants fournis par l’utilisateur. S’il trouve une correspondance, il authentifie l’utilisateur. Dans le cas contraire, l’application affiche le message « Identifiants incorrects ! Vérifiez votre nom d’utilisateur ou votre mot de passe. »

Avant de tester ce code, installez le package Python lxml pour traiter les données XML. Exécutez cette commande pour l’installer :

1pip install lxml

Pour tester le code, appelez la fonction login et transmettez-lui votre nom d’utilisateur et votre mot de passe. Pour ce faire, ajoutez cet extrait de code à la fin de votre fichier main.py :

1login(username="kimkimani", password="6wreD1678")

Pour exécuter le fichier, lancez la commande ci-dessous dans le terminal.

1python3 main.py

Un message de réussite s’affiche. Vous pouvez aussi essayer de vous connecter avec des identifiants incorrects : un message d’échec s’affichera.

Ce code est vulnérable aux attaques par injection XPath, car il ajoute les données saisies par l’utilisateur à la requête XPath, ce qui modifie la structure de la requête et permet d’y injecter du code malveillant.

Une requête XPath classique est une chaîne de texte qui spécifie les éléments à sélectionner dans les données XML.

Dans le code ci-dessus, la requête "/users/userinfo[username='" + username + "' and password='" + password + "']" sélectionne tous les éléments userinfo correspondant au nom d’utilisateur et au mot de passe fournis par l’utilisateur.

Cependant, fournir un nom d’utilisateur et un mot de passe contenant des caractères spéciaux ou des mots-clés utilisés dans les requêtes XPath modifie la structure de la requête et permet à un attaquant de contourner le système de connexion. Par exemple, si l’on saisit "' or 1=1" à la fois comme nom d’utilisateur et comme mot de passe, la requête XPath suivante est générée :

1//users/userinfo[username = '' or 1=1' and password = '' or 1=1' ]

Cette requête sélectionne tous les éléments userinfo dont les attributs username et password sont vides ou égaux à "1=1". L’expression logique "1=1" renvoie toujours true, quelles que soient les valeurs réelles des attributs username et password.

Supposons qu’un attaquant veuille obtenir un accès sans nom d’utilisateur ni mot de passe valides. Au lieu d’identifiants valides, il pourrait saisir l’une des injections XPath suivantes dans le formulaire de connexion, à la fois comme nom d’utilisateur et comme mot de passe :

• 'or'1'='1

• ' or 1=1 or 'a'='a'

• ' or ''=''

• ' or '1'='1'

• 'a' or true() or '

• 'text' or '1' = '1'

Chacune des instructions ci-dessus contourne avec succès la sécurité de l’application en exploitant la logique et la structure des requêtes XPath, car toutes les requêtes XPath générées à partir de ces entrées renvoient toujours true. De plus, si les attaquants connaissent ou peuvent deviner un nom d’utilisateur (par exemple, kimkimani), ils peuvent exécuter la requête suivante :

1kimkimani' or '1'='1

Lorsque nous exécutons cette requête en saisissant un username et un password, la requête obtenue sélectionne l’élément userinfo dont le username kimkimani, tout élément userinfo nommé kimkimani ou '1'='1', ou encore tout élément userinfo dont la valeur de l’attribut username est '1'='1' et celle de l’attribut password est '1'='1'. Comme tous les éléments userinfo remplissent ces conditions, le système de connexion laisse l’attaquant se connecter.

En outre, selon la structure du document XML, un attaquant peut envoyer une injection basée sur la position des nœuds, comme suit :

1'or position()=4 or'

Cette requête permet aux attaquants de contourner l’authentification en fonction de la position de l’utilisateur dans la structure du document XML. La fonction position() est une fonction XPath intégrée qui renvoie la position du nœud courant par rapport à son parent. L’expression ci-dessus renvoie true pour le quatrième nœud du document XML, ce qui permet à l’attaquant de se connecter.

Prévenir les vulnérabilités d’injection XPath

Les moyens d’exploiter des données XML insuffisamment sécurisées ne manquent pas, mais nous disposons de plusieurs méthodes pour atténuer ces vulnérabilités dans nos sites web et nos applications. En voici quelques-unes.

Assainir les entrées

Une stratégie pour prévenir les attaques par injection XPath consiste à filtrer les caractères que les utilisateurs peuvent saisir. Cette méthode n’est pas infaillible, mais elle permet de bloquer les entrées susceptibles de servir à créer des requêtes d’injection.

Pour appliquer cette méthode, créez un fichier regex.py dans le dossier xpath, puis collez-y le code suivant.

1# Import the required modules
2from lxml import etree
3import re
4
5# Parse the XML data
6tree = etree.parse("users_info.xml")
7
8# Create an XPath evaluator
9evaluator = etree.XPathEvaluator(tree, namespaces=None)
10
11# login function
12def login(username, password):
13    if len(re.findall('[^a-zA-Z0-9]', username)) > 0 or ⏎ len(re.findall('[^a-zA-Z0-9]', password))>0:
14        print("Suspected characters detected! Login failed!")
15        return False
16    else:
17        expression = "/users/userinfo[username='" + username + "' and password='" +⏎  password + "']"
18        results = tree.xpath(expression)
19
20        # if no results, which means login details did not match
21        if len(results) < 1:
22            print("Incorrect login details!")
23
24        # if login details match
25        else:
26            for result in results:
27                print("Login successful for user", result[1].text)
28
29login(username="kimkimani", password="6wre1678")

Ce code utilise une expression régulière (regex) pour détecter tous les caractères qui ne sont ni numériques ni alphabétiques. Lorsqu’un tel caractère est détecté, un message « échec de connexion » s’affiche dans le terminal et nous renvoyons immédiatement False à la fonction appelante afin d’empêcher toute exécution de code supplémentaire. Nous pouvons tester le code avec les caractères utilisés dans l’injection XPath présentée dans la section précédente.

Cette méthode améliore la sécurité de nos données, mais la validation des entrées ne filtre que les caractères que nous pensons à inclure dans les fonctions d’assainissement. De plus, les mots de passe devraient contenir des caractères spéciaux : nous ne voulons donc pas bloquer ces entrées.

Examinons donc d’autres méthodes pour éviter les vulnérabilités d’injection XPath.

Utiliser des requêtes XPath paramétrées (préparées)

Pour illustrer cette méthode, créez le fichier params.py dans le dossier xpath, puis collez-y le code suivant :

1# Import the required modules
2from lxml import etree
3
4# Parse the XML data
5tree = etree.parse("users_info.xml")
6
7def login(username, password):
8    expression = "/users/userinfo[username=$username and password=$password]"
9
10    results = tree.xpath(expression, username=username, password=password)
11
12    # if no results, which means login details did not match
13    if len(results) < 1:
14        print("Invalid credentials! Check your username or password.")
15        return False
16    # if login details match
17    else:
18        for result in results:
19            print(f'Login successful! username: {result[1].text}, password:⏎ {result[2].text}')
20
21login(username="kimkimani", password="6wreD1678")

Les requêtes XPath paramétrées nous évitent d’intégrer les données saisies par l’utilisateur à la requête XPath : elles les transmettent plutôt en tant que paramètres. Outre le fait d’être plus sécurisées, ces requêtes sont plus flexibles et réutilisables. Elles ne préviennent toutefois pas toutes les injections. Examinons donc une autre mesure de prévention.

Utiliser des requêtes XPath précompilées

Les requêtes XPath précompilées ne sont pas construites à partir de données fournies par l’utilisateur. Elles constituent donc le seul moyen entièrement sûr de prévenir les attaques par injection. Pour voir comment elles peuvent nous aider, créez un fichier nommé compiled.py et ajoutez-y ce code :

1import lxml.etree as et
2
3xml = et.parse("users_info.xml")
4find = et.xpath("/users/userinfo[username=$username and password=$password]")
5results = find(xml, username="'or'1'='1", password="'or'1'='1")
6print(results)

Le code utilise la fonction etree.xpath pour compiler une requête XPath, puis la stocke dans la variable find. Nous pouvons exécuter cette requête compilée plusieurs fois à l’aide de la fonction find, sans devoir la recompiler à chaque fois. C’est la méthode la plus efficace, car nous n’avons pas à nous soucier des caractères à échapper.

Bonnes pratiques pour détecter et éviter les vulnérabilités d’injection XPath

En plus d’appliquer les mesures de prévention ci-dessus — les requêtes précompilées étant la meilleure pratique —, nous devrions suivre les bonnes pratiques suivantes pour détecter et éviter les vulnérabilités d’injection XPath.

Vérifier les packages et le code pour repérer les vulnérabilités

Utilisez un outil comme Snyk Open Source Advisor pour analyser les packages open source que nous utilisons et détecter d’éventuelles vulnérabilités d’injection XPath. Grâce à son aperçu complet de l’état de santé des packages, Snyk Advisor nous aide à renforcer la confiance dans la sécurité de notre application web.

De même, nous pouvons utiliser Snyk Code pour analyser le code source et détecter d’éventuelles vulnérabilités de sécurité, notamment les injections XPath. Snyk Code permet de repérer rapidement et facilement les vulnérabilités potentielles de notre code et de prendre des mesures pour les corriger.

La capture d’écran ci-dessous présente les résultats de l’analyse du code source du dossier du projet avec Snyk Code.

Éviter d’associer les entrées utilisateur aux requêtes XPath

N’insérez pas directement les données fournies par les utilisateurs dans les requêtes XPath par concaténation. C’est l’une des causes les plus courantes de vulnérabilités d’injection XPath. Utilisez plutôt des requêtes XPath paramétrées, qui permettent de remplacer les données fournies par l’utilisateur par des espaces réservés. Le code est ainsi plus lisible et plus facile à maintenir, ce qui facilite l’assainissement des entrées utilisateur et la prévention des attaques par injection XPath.

Prêter attention aux caractères spéciaux

Si nous ne pouvons pas utiliser de requêtes paramétrées, nous devons correctement échapper tous les caractères spéciaux des données saisies par l’utilisateur avant de les utiliser dans une requête XPath.

Utiliser des instructions préparées et des variables liées

L’utilisation d’instructions préparées et de variables liées dans les requêtes XPath peut aider à empêcher un attaquant d’injecter des requêtes XPath arbitraires dans les entrées d’une application. En effet, les entrées sont traitées comme des valeurs de variable plutôt que comme des éléments de la requête elle-même.

Réviser régulièrement le code

En plus d’utiliser des outils comme Snyk Advisor et Snyk Code, il est essentiel de réviser et de tester régulièrement le code afin de repérer les vulnérabilités potentielles d’injection XPath. Cela permet de les identifier et de les corriger avant qu’un attaquant ne les exploite. Nous pouvons effectuer des revues de code manuelles, utiliser des outils d’analyse automatisée du code comme Snyk Code et réaliser des tests d’intrusion pour identifier et corriger les vulnérabilités.

Conclusion

Les injections XPath peuvent gravement nuire aux sites web, aux données et à la réputation des organisations, et exposer ces dernières à de futures violations. Toutefois, avec quelques efforts supplémentaires, nous pouvons protéger nos applications en utilisant des outils comme Snyk Advisor et Snyk Code, en suivant les bonnes pratiques pour repérer et éviter les vulnérabilités d’injection XPath dans notre code, et en corrigeant les vulnérabilités avec soin.

Nous pouvons sécuriser nos applications contre les attaques par injection XPath en assainissant correctement les données fournies par les utilisateurs, en utilisant des requêtes XPath paramétrées et, surtout, en recourant à des requêtes XPath précompilées. Comme elles ne sont pas construites à partir de données fournies par les utilisateurs, ces dernières constituent le seul moyen entièrement sûr de prévenir les attaques par injection. Compte tenu de leurs conséquences, ces mesures de prévention sont essentielles et ne doivent pas être négligées.