Valider des URL Python en toute sécurité

Tout ce qui se trouve sur Internet possède un localisateur uniforme de ressource (URL) qui l’identifie de manière unique et permet aux internautes d’accéder à des fichiers et à d’autres contenus multimédias. Par exemple, cet article possède une URL unique qui aide les robots d’optimisation pour les moteurs de recherche (SEO) à l’indexer pour que les internautes puissent le trouver.

La première définition de la syntaxe des URL figure dans la demande de commentaires (RFC) 1738, publiée en 1994. Depuis, la structure des URL a fait l’objet de nombreuses révisions visant à renforcer leur sécurité. Cependant, les développeurs ne respectent souvent pas la définition de la RFC, ce qui contribue à de nombreuses attaques malveillantes.

Un exemple récent est l’exploit RCE zero-day découvert dans Log4j, un package de journalisation Java très répandu. Cette attaque s’est produite lorsque l’interface JNDI (Java Naming and Directory Interface) a évalué une chaîne de journal malveillante. JNDI est une API Java pour un service d’annuaire qui permet aux clients logiciels Java de découvrir et de rechercher des données et des ressources (sous forme d’objets Java) à l’aide d’un nom. Lorsqu’elle évalue une chaîne de journal malveillante, elle se connecte à un serveur distant et exécute du code Java malveillant. Les entreprises doivent donc valider en permanence les URL fournies par des agents externes, tels que des clients, des partenaires, etc.

Autre exemple : la falsification de requête côté serveur, une attaque qui peut compromettre un programme serveur lorsque celui-ci accède à une URL non sécurisée. Des utilisateurs malveillants peuvent exploiter les champs de saisie pour nuire à nos solutions web et, pire encore, à l’image publique de notre organisation.

Dans cet article, nous explorons les difficultés liées aux URL altérées, les dommages qu’elles peuvent causer à vos applications et les façons de résoudre le problème. Pour suivre, assurez-vous que Python est installé et configuré sur votre machine.

Risques de sécurité liés aux URL

Les URL peuvent présenter des risques, car elles peuvent rediriger les utilisateurs d’une page web légitime vers une page malveillante. Elles peuvent également ouvrir la voie à plusieurs vecteurs d’attaque, notamment les scripts intersites (XSS), une vulnérabilité de sécurité présente dans certaines applications web. Cette vulnérabilité permet aux attaquants d’injecter des scripts côté client dans les pages web consultées par d’autres utilisateurs.

Ce risque de sécurité peut avoir de graves conséquences dans certains secteurs, comme celui des services bancaires. Un client qui ne se doute de rien peut ouvrir une page d’apparence légitime contrôlée par un attaquant, parce qu’il croit qu’il s’agit de la page de connexion de son application bancaire. Il s’agit d’une forme d’hameçonnage reposant sur l’ingénierie sociale : l’attaquant envoie des messages frauduleux, mensongers ou trompeurs pour inciter une personne à lui révéler des informations sensibles. Il peut aussi déployer des logiciels malveillants sur l’infrastructure de la victime, notamment des rançongiciels. Si l’attaquant récupère le nom d’utilisateur et le mot de passe d’un client bancaire, il peut s’en servir pour accéder à son compte et lui causer du tort.

Des attaques plus sophistiquées exploitant les URL peuvent être menées par falsification de requête côté serveur. Elles ciblent les serveurs qui envoient des requêtes aux URL fournies par les clients. Lorsqu’il effectue une requête, un attaquant peut prendre le contrôle du serveur pour réaliser des actions non autorisées, comme analyser les ports et les informations réseau, demander les métadonnées de l’infrastructure, ou encore imprimer et afficher des informations sensibles telles que des mots de passe ou des jetons.

Les sections suivantes montrent comment valider et assainir les URL que vous ne contrôlez pas. Par exemple, si nous créons une plateforme sociale où les utilisateurs peuvent communiquer et partager des données, nous pouvons contrôler les URL autorisées et celles que nous pouvons masquer.

Comment valider des URL en Python

Python, un langage de programmation, est largement utilisé pour créer des applications et des sites web destinés à des millions de clients dans le monde. Python ne dispose pas d’un outil intégré pour analyser et valider les URL, mais la communauté a créé des analyseurs et des validateurs d’URL pour Python, qui permettent de valider nos URL et de les rendre plus sûres. Certains frameworks d’applications web proposent également des outils d’analyse et de validation des URL.

Valider des URL

Le package Python validators est une méthode populaire pour valider des URL. Nous pouvons l’utiliser pour déterminer si une URL est valide. Pour qu’elle le soit, une URL doit :

• Être bien formée, c’est-à-dire respecter toutes les règles des spécifications HTTP ou HTTPS

• Pointer vers une ressource existante, car une URL sans ressource associée est invalide

Le package Python validators fournit une méthode URL qui vérifie l’URL, teste sa sécurité et recherche les mots-clés et caractères non valides. Si une URL est accessible publiquement (c’est-à-dire qu’elle n’est pas derrière un pare-feu, un péage ou une autre barrière d’accès), le package ignore les adresses IP internes.

Pour utiliser le package validators, téléchargez et configurez la dépendance dans votre environnement Python local à l’aide de pip. Pour télécharger le package validators, exécutez le code suivant dans votre terminal ou votre interface de ligne de commande :

1$ python3 -m pip install validators

Une fois cette commande exécutée, le package validators sera installé sur notre machine.

Ensuite, créez un fichier Python nommé main.py et écrivez le code Python permettant de tester une URL :

1import validators
2
3validation = validators.url("http:/www.google.com")
4if validation:
5print("URL is valid")
6else:
7print("URL is invalid")

Après avoir ajouté ce code au fichier main.py, exécutez-le dans l’interpréteur Python à l’aide de l’interface de ligne de commande Python :

1$ python main.py

Le code affiche "URL is invalid", car il manque un caractère / dans l’URL après http:/.

Le package peut également déterminer si une URL est accessible publiquement, ce qui est utile pour vérifier si l’utilisateur tente d’accéder à une adresse IP interne. Ajoutez le code suivant au même fichier et exécutez-le pour tester la validation d’une URL.

1validation = validators.url("https://10.0.0.1", public=True)
2if validation:
3print("URL is valid")
4else:
5print("URL is invalid")

Une fois encore, le résultat indique que l’URL est invalide. En effet, elle n’est pas accessible publiquement, même si elle ne présente aucun problème en elle-même. Pour en savoir plus sur les fonctionnalités du package validators, consultez sa documentation.

Analyse à l’aide d’expressions régulières

Les expressions régulières constituent une autre méthode de validation des URL. Nous pouvons, par exemple, exiger qu’une URL commence par HTTPS avant de la valider. Le code permettant cette validation est le suivant :

1^https:\/\/[0-9A-z.]+.[0-9A-z.]+.[a-z]+$

Cette expression régulière correspond à https://www.google.com, mais pas à http://www.google.com, bien que les deux soient des URL valides. Pour en savoir plus sur les expressions régulières, consultez ce site web. Nous pouvons tester l’expression ci-dessus en Python :

1import re
2
3pattern = "^https:\/\/[0-9A-z.]+.[0-9A-z.]+.[a-z]+$"
4result = re.match(pattern, "https://www.google.com")
5
6if result: 
7print(result)
8else:
9print("Invalid URL")

Le code ci-dessus affiche l’URL correspondante. Si vous modifiez la chaîne de l’URL ci-dessus et supprimez HTTPS ou la remplacez par HTTP, vous obtenez un objet None, ce qui signifie qu’aucune URL ne correspond.

Toutefois, les expressions régulières sont complexes et peu adaptées aux situations concrètes. Elles sont difficiles à lire, à déboguer et à faire évoluer. C’est pourquoi les bibliothèques constituent généralement une meilleure solution.

Pour découvrir un exemple plus avancé d’expression régulière qui analyse une URL en respectant toutes les structures et syntaxes conformes, consultez cette discussion Stack Overflow.

L’un des avantages des expressions régulières est qu’elles permettent également de repérer des URL invalides dans des chaînes de saisie. Seules les expressions régulières le permettent, contrairement aux bibliothèques courantes. Le package validators ne fonctionne pas si la chaîne contient des espaces au début ou à la fin. Pour utiliser le package correctement, vous devez assainir la chaîne de saisie avant de la transmettre au validateur.

Utiliser urllib

urllib est un autre package qui analyse une URL et en extrait les différentes parties. Nous pouvons l’utiliser avec l’interpréteur Python 3.

Le code suivant vérifie si une URL est valide :

1from urllib.parse import urlparse
2result = urlparse("https:/www.google.com")
3if result.scheme and result.netloc:
4print("Success")
5else:
6print("Failed")
7
8print(result)

Lorsque nous définissons le schéma et le champ netloc de la variable result, l’URL est valide et peut être utilisée. Dans le cas contraire, elle est invalide et doit être utilisée avec prudence.

Identifier les vulnérabilités courantes

Certains frameworks Python, comme Django, proposent des packages de validation intégrés qui permettent de valider les URL au sein du framework. Cependant, s’appuyer sur ces bibliothèques pose un problème : même si nous connaissons bien le framework, nous devons toujours nous assurer que le package lui-même est sécurisé. Et le fait qu’un package soit open source ne fait que compliquer la confiance que nous pouvons lui accorder.

Nous pouvons utiliser un outil de sécurité comme Snyk Advisor pour examiner rapidement tous les packages open source que nous utilisons, ainsi que ceux que nous envisageons d’adopter, afin d’y repérer les vulnérabilités courantes. À l’issue de cet examen, Snyk nous fournit un rapport de sécurité qui nous aide à décider si le package doit être intégré ou non. Par exemple, nous pouvons utiliser Snyk Advisor pour vérifier la sécurité de nos packages, comme le package validators utilisé dans la démonstration ci-dessus.

Nous pouvons également utiliser Snyk Open Source avec Snyk Advisor pour détecter les problèmes de licence, les vulnérabilités et d’autres risques de sécurité dans notre environnement d’outils open source. Nous pouvons aussi consulter la Snyk Vulnerability Database (VulnDB) pour rechercher les vulnérabilités connues liées aux URL, comme cette vulnérabilité du framework Flask, qui redirige un utilisateur vers une page sans valider l’URL. En consultant cette base de données, nous pouvons sécuriser proactivement nos pages web et nos applications.

Valider des URL en Python

Dans cet article, nous avons examiné les problèmes que les URL non assainies peuvent poser à une application web et comment les assainir au besoin. Nous avons commencé par valider les URL à l’aide des packages validator et urllib. Nous avons montré comment les utiliser pour vérifier que les URL sont accessibles publiquement ou s’il s’agit d’URL internes susceptibles de servir à attaquer l’application web. Nous avons ensuite utilisé une expression régulière simple pour montrer qu’une seule ligne de code peut vérifier des critères de base, par exemple que toutes les URL utilisent HTTPS. Nous avons également expliqué pourquoi les expressions régulières sont une méthode complexe et difficile à mettre en œuvre pour valider des URL.

Enfin, nous avons vu comment choisir des bibliothèques open source sécurisées. Snyk Advisor est une source de référence précieuse pour l’utilisation de packages open source. Pour en savoir plus, consultez l’aide-mémoire sur les bonnes pratiques de sécurité Python afin de préparer vos pipelines d’intégration et de déploiement continus (CI/CD) à détecter les vulnérabilités ajoutées à votre code.