Dans le monde de la sécurité Web, la pollution des prototypes est une vulnérabilité subtile mais potentiellement dévastatrice qui peut entraîner de graves conséquences si elle n'est pas traitée correctement. Dans ce blog, nous explorerons ce qu’est un prototype de pollution, comment elle se produit et, surtout, comment la prévenir. Allons-y !

Qu’est-ce que la pollution prototype ?

La pollution des prototypes est un type de vulnérabilité qui affecte les applications JavaScript. Cela se produit lorsqu'un attaquant parvient à injecter des propriétés dans le prototype d'un objet, qui peuvent ensuite se propager à tous les objets héritant de ce prototype. Cela peut entraîner un comportement inattendu, notamment la possibilité d'écraser les méthodes et propriétés existantes, compromettant ainsi la sécurité et les fonctionnalités de l'application.

Comment se produit la pollution des prototypes

Pour comprendre comment se produit la pollution des prototypes, nous devons examiner de plus près les objets et prototypes JavaScript. En JavaScript, chaque objet possède un prototype, qui est un autre objet dont le premier objet hérite des propriétés et des méthodes. Ce chaînage de prototypes permet une recherche efficace des propriétés, mais ouvre également la porte à des attaques potentielles si elles ne sont pas gérées correctement.

Voici un exemple simple de la façon dont la pollution prototype peut se produire :

let obj = {};
console.log(obj.constructor); // function Object() { [native code] }

obj.__proto__.polluted = true;
console.log({}.polluted); // true

Dans cet exemple, en modifiant la propriété proto d'obj, nous affectons par inadvertance tous les objets qui partagent le même prototype, démontrant à quel point il est facile de polluer la chaîne de prototypes.

Exemple concret de pollution prototype

Considérons un scénario dans lequel la saisie de l'utilisateur est utilisée pour étendre ou fusionner des objets sans validation appropriée. Un cas d'utilisation courant consiste à fusionner les paramètres de requête dans un objet de configuration.

const merge = require('lodash/merge');

let config = {};
let query = JSON.parse('{"__proto__":{"admin":true}}');

merge(config, query);

console.log(config.admin); // undefined
console.log({}.admin); // true

Dans cet exemple, la fonction de fusion de la bibliothèque Lodash est utilisée pour combiner la configuration avec la requête. Cependant, l'objet de requête contrôlé par l'attaquant inclut une propriété proto qui pollue le prototype d'objet global, définissant admin sur true pour tous les objets.

Prévenir la pollution des prototypes

Pour protéger vos applications de la pollution des prototypes, pensez à mettre en œuvre les mesures suivantes :

1. Évitez d'étendre les prototypes natifs :
N'étendez pas directement les prototypes natifs (par exemple, Object.prototype), car cela peut entraîner des conflits et des vulnérabilités de sécurité.

Exemple : évitez d'étendre les prototypes natifs
Évitez de faire ceci :

Object.prototype.polluted = true; // Extending native prototype

let obj = {};
console.log(obj.polluted); // true

Au lieu de cela, créez des méthodes utilitaires dans votre propre espace de noms :

const myUtils = {
  polluted: function() {
    // Your method implementation
  }
};

let obj = {};
console.log(obj.polluted); // undefined

2. Valider la saisie de l'utilisateur : 
Validez et désinfectez toujours les entrées de l’utilisateur avant de les utiliser pour construire ou modifier des objets. Utilisez des bibliothèques comme Joi ou Validator pour appliquer des règles strictes de validation des entrées.

Exemple : valider la saisie de l'utilisateur à l'aide de Joi

const Joi = require('joi');

const schema = Joi.object({
  admin: Joi.boolean().required()
});

const input = JSON.parse('{"admin":true}');

const { error, value } = schema.validate(input);

if (error) {
  console.error('Invalid input:', error.details);
} else {
  console.log('Valid input:', value);
}

3. Utiliser des méthodes d'objet sécurisées :

Préférez utiliser des méthodes d'objet sécurisées qui ne traversent pas la chaîne de prototypes, telles que Object.create(null) pour créer des objets simples sans prototype.

Exemple : Utiliser des méthodes d'objet sécurisées

let safeObj = Object.create(null);
safeObj.admin = false;

console.log(safeObj.constructor); // undefined
console.log(safeObj.admin); // false

4. Geler le prototype :

Gelez le Object.prototype pour empêcher toute modification de la chaîne de prototypes. Cela peut être fait en utilisant Object.freeze().

Exemple : Geler le prototype

Object.freeze(Object.prototype);

let obj = {};
try {
  obj.__proto__.polluted = true;
} catch (e) {
  console.error('Attempt to modify prototype failed:', e);
}

console.log({}.polluted); // undefined

5. Mettre à jour les dépendances :

Mettez régulièrement à jour vos dépendances pour vous assurer que vous utilisez les dernières versions incluant des correctifs de sécurité. Les vulnérabilités des bibliothèques tierces sont souvent exploitées pour des prototypes d'attaques de pollution.

Exemple : mise à jour des dépendances à l'aide de npm

npm update

Exécutez cette commande régulièrement pour vous assurer que tous vos packages sont à jour.

6. Surveiller et tester :
Mettre en œuvre une surveillance et des tests automatisés pour détecter et atténuer les vulnérabilités des prototypes en matière de pollution. Des outils tels que npm audit peuvent vous aider à identifier les packages vulnérables dans votre projet.

Exemple : Surveillance et tests avec npm audit

npm audit

Exécutez cette commande pour analyser votre projet à la recherche de vulnérabilités. Il fournit un rapport sur les problèmes détectés et suggère des étapes de remédiation.

Conclusion

La pollution prototype est une vulnérabilité critique qui peut avoir des conséquences considérables si elle n'est pas maîtrisée. En comprenant comment cela se produit et en mettant en œuvre les meilleures pratiques pour l'éviter, vous pouvez améliorer considérablement la sécurité de vos applications JavaScript. Restez vigilant, gardez vos dépendances à jour et validez toujours les entrées des utilisateurs pour vous protéger contre ce vecteur d'attaque insidieux.

Si vous avez trouvé ce blog utile, assurez-vous de le partager avec vos collègues développeurs et passionnés de sécurité. Rester informé et proactif est essentiel pour maintenir une sécurité Web robuste. Bon codage !