L'attaque de pollution par prototype exploite la manière dont les objets JavaScript traitent leurs prototypes correspondants. En JavaScript, les prototypes sont un autre objet qui définit les propriétés et méthodes par défaut de l'objet sélectionné. Un attaquant exploite la pollution des prototypes en injectant du code malveillant dans ces prototypes en manipulant les propriétés de l’objet ou en utilisant une fonction qui fusionne les objets de manière récursive.
Ce guide explique les moyens de prévenir les attaques de prototypes de pollution.
Prévenir les attaques de pollution prototypes ?
La cause première des attaques de pollution par prototype est que les objets JavaScript héritent des propriétés de leur prototype. Cela signifie que si un attaquant parvient à injecter du code malveillant dans le prototype, tous les objets hérités de ce prototype en hériteront. Cela conduit au vol de données, à l’exécution de code arbitraire ou à la prise de contrôle d’autres applications.
Dans l'extrait de code ci-dessous, le prototype de code de pollution va être injecté :
const y = { un: 1 , b : 2 } ;
données const = JSON.parse ( '{'__proto__': { 'défectueux': vrai}}' ) ;
const c = Objet.assign ( { } , et, les données ) ;
console.log ( c. défectueux ) ;
La description de l'extrait de code ci-dessus :
-
- Tout d’abord, la liste nommée « et ' est créé et il stocke les valeurs dans la paire clé-valeur.
- Avec l'aide de ' -donc- », le code pollué aléatoire est implémenté au format clé-valeur. La clé est réglée sur « défectueux ' et la valeur attribuée de ' vrai ».
- Ensuite, ce code pollué est attribué au « et » liste en invoquant le « attribuer() ', et la liste résultante est stockée dans une nouvelle liste nommée ' c ».
- Finalement, le code pollué injecté dans le « c ' La liste est récupérée et sa valeur est affichée sur la console. Pour s’assurer que de la pollution ou des données malveillantes ont été injectées.
Après l'exécution du fichier conteneur, le résultat montre que le code malveillant a été injecté avec succès et que sa valeur a été récupérée :
Comment prévenir les attaques de pollution prototypes ?
Il existe plusieurs approches permettant de prévenir les prototypes d’attaques de pollution :
Fusions récursives non sécurisées :
Évitez les fusions récursives non sécurisées car elles peuvent conduire à des prototypes d'attaques de pollution :
où fusionner = ( prend , src ) = > {pour ( attributs var dans src ) {
si ( Type de ( prend [ les attributs ] ) === 'obj' && Type de ( src [ les attributs ] ) === 'obj' )
{
fusionner ( prend [ les attributs ] , src [ les attributs ] ) ;
} autre {
prend [ les attributs ] = src [ les attributs ] ;
}
}
retour prend ;
} ;
Dans le code ci-dessus :
-
- Tout d’abord, la fonction personnalisée « fusionner() ' est créé et accepte deux paramètres de tableau ' prend ' et ' src ».
- Le « amélioré » pour ' La boucle est utilisée pour itérer la variable ' les attributs ' sur le fourni ' src ' paramètre.
- À l’intérieur de la boucle, utilisez un « si ' qui parcourt les deux erreurs et si un élément résidant dans les deux tableaux a le même type de données. Ensuite, ces éléments sont passés en tant que paramètres au même ' fusionner() » fonction créant un caractère récursif.
- Si les types ne sont pas les mêmes, la valeur de l'élément résidant dans le ' src ' Le tableau de paramètres est passé au ' prend ' paramètre.
- Finalement, le ' prend ' Un tableau paramétrique est renvoyé.
Geler le prototype
Une autre prévention contre les prototypes d’attaques de pollution consiste à geler leur cycle d’exécution. Cela se fait via le ' Objet.freeze() ' méthode. Dans l'extrait ci-dessous, le code pollué prototypé injecté ci-dessus va être gelé :
const y = { un: 1 , b : 2 } ;données const = JSON.parse ( '{'__proto__': { 'défectueux': vrai}}' ) ;
const c = Objet.assign ( { } , et, les données ) ;
console.log ( c. défectueux ) ;
console.log ( Objet.freeze ( c. défectueux ) ) ;
console.log ( Objet.isFrozen ( c. défectueux ) ) ;
L'explication du code ci-dessus est présentée ci-dessous :
-
- Dans un premier temps, le code pollué du prototype factice va être injecté dans la liste factice » et » comme expliqué dans la section ci-dessus.
- Ensuite, la clé polluée injectée » défectueux ' est transmis au ' geler() » méthode pour geler la partie polluée.
- Enfin, pour confirmer la partie pollution du prototype gelé. Le ' défectueux « clé de liste » c ' est transmis au ' est gelé() ' méthode. Cette méthode renvoie « vrai » en cas de gel et « FAUX » en cas de dégel :
Après avoir exécuté le code conteneur, le résultat montre que l'injection, le gel et la vérification du code pollué gelé :
Conseils supplémentaires pour prévenir les attaques de pollution prototypes
Quelques conseils supplémentaires grâce auxquels l’attaque de pollution prototype peut être évitée sont indiqués ci-dessous :
-
- L'option de ' –désactiver-proto ' peut être utilisé pour désactiver ou arrêter le fonctionnement du ' prototype.__proto__ ' propriété.
- N'utilisez pas de méthodes à l'aide de ' prototype ».
- Par ' Nettoyage de l'entrée utilisateur » qui consiste à valider et filtrer les entrées des utilisateurs pour supprimer tout code malveillant ou pollué.
- Utilisation de « liste blanche », qui est une liste de propriétés et de méthodes autorisées pour un objet. Toute tentative de définition ou d'obtention de propriétés ou de méthodes qui ne sont pas membres de la liste blanche sera bloquée.
Il s’agit de prévenir les prototypes d’attaques de pollution dans Node.js.
Conclusion
Pour prévenir les attaques de pollution par prototype, des approches telles que l'évitement des fusions récursives non sécurisées, le gel du prototype et l'utilisation d'une liste blanche pour empêcher le « __donc__ 'La propriété en cours de définition peut être utilisée. Parallèlement à l’utilisation de « –désactiver-proto ' options, en évitant l'utilisation de ' Objet.prototype ', et ' nettoyer l'entrée utilisateur » pour code pollué. Ce guide a illustré la prévention des prototypes d'attaques de pollution dans Nodejs.