Validation sécurisée des URL JavaScript

Lorsqu’il faut gérer des URL sous différentes formes et à différentes fins — navigation dans l’historique du navigateur, cibles d’ancrage, paramètres de requête, etc. — les développeurs se tournent souvent vers JavaScript. Mais son utilisation fréquente incite les attaquants à exploiter ses vulnérabilités. Ce risque d’exploitation nous impose de mettre en œuvre la validation des URL dans nos applications JavaScript.

La validation des URL consiste à vérifier qu’elles respectent la syntaxe prévue, c’est-à-dire la structure que toute URL doit avoir. Elle peut protéger nos applications contre les vulnérabilités liées aux URL, comme l’injection de scripts malveillants et la falsification de requêtes côté serveur (SSRF). Les acteurs malveillants peuvent lancer des attaques SSRF si nous ne suivons pas les bonnes pratiques de codage pour valider les URL fournies par les utilisateurs lors de la récupération d’une ressource distante. Les SSRF restent une menace critique pour les applications JavaScript, aussi bien côté frontend que côté serveur Node.js, et figuraient parmi les catégories mises en avant dans la liste OWASP Top 10 en 2021.

Validation des URL

La validation des URL renforce la sécurité contre les exploits potentiels et évite l’apparition de bugs lors de l’exécution du code. Mais quand faut-il y recourir, et que faut-il valider ? Nous devrions mettre en œuvre la validation des URL dans tous les logiciels qui doivent identifier et vérifier des ressources comme des pages, des images, des GIF et des vidéos.

Une URL classique se compose de plusieurs éléments : protocole, nom de domaine, nom d’hôte, nom de ressource, origine, port, etc. Ils indiquent au navigateur comment récupérer la ressource concernée. Nous pouvons nous en servir pour valider les URL de plusieurs façons :

• Utiliser des expressions régulières littérales et des constructeurs

• Constructeurs d’URL

• Méthode isValidURL

• Éléments de saisie

• Méthode de la balise d’ancrage

Un mécanisme classique de validation des URL reçoit une saisie de l’utilisateur, puis l’analyse pour en identifier les différents éléments. Il peut vérifier que tous les éléments de l’URL sont conformes aux normes Internet. Par exemple, il peut vérifier si l’URL utilise un protocole sécurisé, lorsque cela est nécessaire.

La validation du nom d’hôte commence par sa décomposition en libellés distincts afin de vérifier leur conformité à la spécification des noms de domaine de premier niveau. Un nom d’hôte classique comporte au moins deux libellés séparés par des points. Par exemple, www.snyk.com se compose des libellés « www », « snyk » et « com ». Chaque libellé peut contenir uniquement des caractères alphanumériques ou des traits d’union, quelle que soit la casse. Le mécanisme de validation peut ensuite vérifier que le nom d’hôte correspond à une liste d’autorisation d’URL, afin de n’autoriser que les URL prévues et de ne pas exclure à tort celles qui sont autorisées.

La plupart des chemins d’accès à une ressource utilisés dans les URL sont autorisés par défaut. En revanche, les ports doivent être compris entre 1 et 65536. Toute valeur en dehors de cette plage doit déclencher une erreur. Nous pouvons également examiner les adresses IP numériques pour déterminer s’il s’agit d’une adresse IPV4 ou IPV6.

Enfin, même si cela ne semble pas évident au premier abord, nous pouvons aussi vérifier la présence de noms d’utilisateur et de mots de passe dans les URL. Cette vérification contribue au respect des politiques de l’entreprise et à la protection des identifiants.

Maintenant que vous connaissez les bases, voyons comment valider des URL avec javascript !

Comment valider une URL en JavaScript

Le moyen le plus simple de valider une URL en JavaScript consiste à utiliser la fonction constructeur new URL. En plus d’être simple, elle est prise en charge par l’environnement d’exécution Node.js et par la plupart des navigateurs.

La syntaxe de base est la suivante :

1new URL (url)
2new URL (url , base)

JavaScript n’a besoin de l’élément base que si nous fournissons une URL relative. En son absence, sa valeur par défaut est undefined. À l’inverse, si nous fournissons un élément base avec une URL absolue, JavaScript ignore l’élément base.

Pour valider l’URL, vous pouvez utiliser la fonction suivante :

1function checkUrl (string) {
2    let givenURL ;
3    try {
4        givenURL = new URL (string);
5    } catch (error) {
6        console.log ("error is", error);
7       return false; 
8    }
9    return true;
10  }

Cette fonction vérifie la validité d’une URL : elle renvoie true si l’URL est valide et false dans le cas contraire. Si vous lui transmettez www.urlcheck.com, elle renverra false, car cette URL ne contient pas de schéma valide. La forme correcte est https://urlcheck.com. Autre exemple : mailto:John.Doe@example.com. Il s’agit d’une URL valide, mais si vous supprimez les deux-points, JavaScript ne la reconnaîtra plus comme une URL. Enfin, ftp:// n’est pas valide, car il ne contient pas de nom d’hôte. Si vous ajoutez deux points (..), l’URL devient valide, car les points sont alors considérés comme un nom d’hôte : ftp://.. est donc une URL valide.

Gardez à l’esprit qu’il existe des URL peu conventionnelles, mais parfaitement valides ! Elles peuvent surprendre les développeurs qui les rencontrent, mais elles sont tout à fait acceptables. Par exemple, les deux URL suivantes renvoient TRUE :

• new URL("youtube://a.b.c.d");

• new URL ("a://1.2.3.4@1.2.3.4");

Ces exemples rappellent que les développeurs doivent s’appuyer sur les principes de validation des URL plutôt que sur les conventions.

Pour vérifier qu’une URL valide utilise un schéma spécifique, vous pouvez utiliser la fonction suivante :

1  function checkHttpUrl(string) {
2    let givenURL;
3    try {
4        givenURL = new URL(string);
5    } catch (error) {
6        console.log("error is",error)
7      return false;  
8    }
9    return givenURL.protocol === "http:" || givenURL.protocol === "https:";
10  }

Cette fonction valide l’URL, puis vérifie si elle utilise le schéma HTTP ou HTTPS. Ici, ftp://.. sera invalide, car il n’utilise ni HTTP ni HTTPS, tandis que http://.. reste valide. Voici quelques autres façons d’utiliser la fonction constructeur URL :

1  let m = 'https://snyk.io';
2  let a = new URL("/", m);

L’exemple ci-dessus utilise l’élément base. L’affichage de sa valeur renvoie https://snyk.io/.

Pour renvoyer un objet URL sans préciser le paramètre base, utilisez la syntaxe suivante :

1  let b = new URL(m);

Pour ajouter un chemin à l’hôte, procédez ainsi :

1  let d = new URL('/en-US/docs', b);

L’URL stockée dans d est https://snyk.io/en-US/docs.

Autre fonctionnalité du module URL : il implémente l’API URL WHATWG, conforme à la norme URL WHATWG utilisée par les navigateurs :

1  let adr = new URL("https://snyk.io/en-US/docs");
2  let host = adr.host;
3  let path = adr.pathname;

Dans l’exemple ci-dessus, nous avons créé un objet URL appelé adr. Le code a ensuite récupéré l’hôte et le chemin d’accès de l’URL, à savoir snyk.io et /en-US/docs. Enfin, nous pouvons comparer l’URL à une liste d’autorisation ou de blocage afin de n’autoriser que les URL prévues et de ne pas exclure à tort celles qui sont autorisées.

Comment valider une URL avec une expression régulière — même si c’est déconseillé

Une autre façon de valider une URL consiste à utiliser une expression régulière (regex), c’est-à-dire une chaîne qui définit un motif de recherche. Nous pouvons utiliser une regex pour vérifier si l’URL est valide.

Voici la syntaxe JavaScript pour valider une URL avec une regex :

1  function isValidURL(string) 
2        {
3            var res = 
4            string.match(/(https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9][a-zA-Z0-9-
5            ]+[a-zA-Z0-9]\.[^\s]{2,}|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]
6            \.[^\s]{2,}|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]+\.[^\s]{2,}|w
7            ww\.[a-zA-Z0-9]+\.[^\s]{2,})/gi);
8        return (res !== null);
9        };

Pour tester quelques URL :

1  var tc1 = "http://helloworld.com"
2  console.log(isValidURL(tc1));

La syntaxe d’URL définie par la regex vérifie si l’URL commence par le schéma http:// ou https://, ou par un sous-domaine, et si elle contient un nom de domaine. La console affiche true, car l’URL respecte la syntaxe définie par la regex. À l’inverse, l’instruction suivante renverra la valeur false, car elle ne commence par aucun des schémas autorisés ni par un sous-domaine, et ne contient pas de nom de domaine :

1  var tc4 = "helloWorld";
2  console.log (isValidURL(tc4));

La regex ci-dessus est relativement simple, mais reste difficile à lire. Cette approche est également sujette aux erreurs, car une regex ne peut pas gérer correctement toutes les règles de validation d’une URL. Tout au plus peut-elle faire correspondre les URL valides. De plus, la vérification peut prendre beaucoup de temps si l’expression régulière contient une logique de validation complexe ou reçoit une chaîne d’entrée longue.

Pour satisfaire aux critères de validation définis par la regex, le navigateur doit effectuer des retours arrière des millions de fois dans la chaîne d’entrée. Ces vérifications peuvent entraîner un « retour arrière catastrophique » : des expressions régulières complexes peuvent bloquer le navigateur ou saturer les processus du cœur du processeur.

Snyk détecte les packages open source vulnérables

Les responsables de la maintenance peuvent eux aussi se tromper dans la validation des URL, ce qui expose les applications Node.js. Le package npm keycloak-connect, qui enregistre plus de 50 000 téléchargements par semaine, en est un exemple. En mars 2023, une pratique non sécurisée de validation des URL a été signalée comme permettant une vulnérabilité de redirection ouverte via CVE-2023-2237.

Nous vous recommandons vivement d’analyser gratuitement vos projets avec Snyk pour détecter les dépendances open source vulnérables et les corriger.

Vulnérabilités et mesures correctives concrètes

Node.js est un environnement d’exécution JavaScript gratuit, open source et multiplateforme qui utilise un gestionnaire de packages appelé Node Package Manager (npm).

Un incident similaire s’est produit en 2019, lorsqu’un attaquant a obtenu à lui seul un accès non autorisé aux données de Capital One, l’une des plus grandes banques des États-Unis. Cette fuite de données reste l’une des plus importantes du siècle. Selon The New York Times, l’attaquant a accédé à 100 millions de dossiers clients, 140 000 numéros de sécurité sociale et 80 000 coordonnées bancaires associées à des clients de Capital One.

L’attaquant a accédé au serveur de Capital One hébergé par Amazon Web Services (AWS). Le délai avant la détection indique qu’il connaissait très bien l’infrastructure AWS et avait repéré une vulnérabilité exploitable dans le pare-feu d’applications web (WAF) du fournisseur de services de sécurité gérés (MODSEC). Fort de ces connaissances, il a lancé une attaque SSRF et envoyé de nouvelles requêtes HTTP en manipulant le serveur web vulnérable, accédant ainsi au service de métadonnées AWS.

Selon les exigences de l’entreprise, nous pouvons prévenir les attaques SSRF en limitant le système à quelques protocoles, comme HTTP ou HTTPS. Pour renforcer la sécurité, nous devons configurer l’application de façon à ce qu’elle ne transmette pas le paramètre URL sans contrôle. Les listes d’autorisation et de blocage servent généralement à filtrer et à contrôler le mécanisme, réduisant considérablement le risque d’attaque SSRF. Les listes d’autorisation permettent à l’application d’utiliser un ensemble prédéfini d’objets et de serveurs. Les listes de blocage, quant à elles, empêchent l’application de récupérer des noms d’hôte couramment disponibles.

Utiliser JavaScript en toute sécurité

Comme le montre l’ajout des SSRF au nouveau OWASP Top 10, la validation des URL est devenue essentielle à la sécurité des applications JavaScript. Heureusement, nous pouvons contribuer à limiter ces attaques en validant les URL côté serveur. Il est également très utile d’utiliser la nouvelle fonction URL conformément aux méthodes recommandées pour valider et manipuler des URL.

Après avoir étudié quelques cas d’usage de la nouvelle fonction URL, nous avons appris à valider une URL avec une regex et vu pourquoi cette approche est lourde et sujette aux erreurs. Nous avons ensuite conclu par une étude de cas sur une vulnérabilité SSRF en JavaScript.

Les risques de sécurité liés aux URL concernent moins leur validité que leurs schémas dangereux. Nous devons donc veiller à ce que la validation soit effectuée par l’application côté serveur. Un attaquant peut contourner le mécanisme de validation côté client : il ne faut donc pas s’y fier exclusivement.

Pour en savoir plus sur la gestion de la sécurité de vos applications et sur le produit Snyk, rendez-vous sur Snyk dès aujourd’hui.