flawopen.com/Vulnérabilités/Pollution de prototypes JavaScript

Pollution de prototypes JavaScript

Concepts clés et termes du sous-système

Object.prototype

Prototype partagé hérité par les objets ordinaires. Sa pollution peut affecter de nombreux objets, mais pas tous les objets JavaScript ni tous les realms.

__proto__

Accesseur historique des objets ordinaires qui lit ou définit leur prototype. Dans du JSON, cette graphie est un nom de propriété ordinaire jusqu’à son traitement dangereux par du code ultérieur.

Fusion récursive profonde

Fonction qui parcourt des clés imbriquées et les écrit dans un autre objet. Elle devient dangereuse si des clés non fiables sélectionnent des propriétés liées aux prototypes ou des chemins non sûrs.

CWE-1321

Modification insuffisamment contrôlée des attributs de prototype d’objet. La faiblesse est la mutation non contrôlée; l’impact dépend ensuite du comportement accessible de l’application.

Déroulement de l’attaque, étape par étape

Mécanisme et cause racine

La recherche de propriétés JavaScript suit la chaîne de prototypes. Une fusion vulnérable ou un setter de chemin peut laisser des clés non fiables comme __proto__ ou constructor.prototype diriger une écriture vers un prototype. Un champ propre __proto__ créé par JSON.parse n’est pas une pollution en soi; un autre code doit l’interpréter par une affectation non sûre. Modifier le prototype d’une cible affecte cette cible; modifier Object.prototype affecte les objets ordinaires qui en héritent. Un gadget distinct doit utiliser la propriété héritée pour qu’il y ait un impact de sécurité.

// VULNÉRABLE : des clés contrôlées par l’attaquant atteignent les écritures récursives
function merge(target, source) {
    for (const key in source) {
        const value = source[key];
        if (value && typeof value === 'object') {
            if (!target[key]) target[key] = {};
            merge(target[key], value);
        } else {
            target[key] = value;
        }
    }
    return target;
}
// JSON.parse crée une propriété propre __proto__ ; la fusion non sûre est le risque.
const input = JSON.parse('{"__proto__": {"isAdmin": true}}');
merge({}, input);

// SÉCURISÉ : ne copier que les champs acceptés par cet endpoint
const PROFILE_KEYS = new Set(['displayName', 'theme']);

function parseProfile(input) {
    if (!input || typeof input !== 'object' || Array.isArray(input)) {
        throw new TypeError('profile must be an object');
    }

    const profile = Object.create(null);
    for (const key of Object.keys(input)) {
        if (!PROFILE_KEYS.has(key)) continue;
        const value = input[key];
        if (typeof value !== 'string' || value.length > 80) {
            throw new TypeError('invalid profile field');
        }
        profile[key] = value;
    }
    return profile;
}

Séquence d’attaque et d’exploitation

• 1Entrée : une requête contient une clé d’objet inattendue, par exemple {"__proto__": {"admin": true}}. L’analyse JSON seule ne modifie pas de prototype.
• 2Écriture non sûre : une fusion générique ou un setter de chemin traite la clé sans liste d’autorisation.
• 3Accès au prototype : l’écriture peut modifier le prototype de la cible ou atteindre un prototype partagé, selon le chemin de code.
• 4Gadget d’impact : la pollution n’affecte une décision sensible que si le code ultérieur fait confiance à une propriété héritée. Testez le gadget et le parcours d’autorisation réels.

Mesures défensives et règles de prévention

• ✓Préférez les listes d’autorisation de schéma : construisez la cible uniquement avec les champs prévus par l’endpoint. Si un écrivain de chemin générique est indispensable, rejetez les segments liés aux prototypes à chaque niveau.
• ✓Utilisez des dictionnaires sûrs : stockez les clés arbitraires dans Map ou un dictionnaire Object.create(null); validez les données avant de les transmettre aux API qui attendent des objets ordinaires.
• ✓Vérifiez les propriétés propres : utilisez Object.hasOwn(record, key) pour les contrôles sensibles; ne laissez pas des valeurs héritées autoriser des actions.
• ✓Utilisez le durcissement du runtime en défense en profondeur : --disable-proto=throw de Node.js supprime une voie, mais pas constructor.prototype. Geler les objets natifs peut casser polyfills et dépendances; vérifiez la compatibilité et ne remplacez jamais les écritures sûres par cette mesure.

Questions fréquentes

• MDN — Pollution de prototypes JavaScript
• OWASP — Guide de prévention de la pollution de prototypes
• CWE-1321 — Modification insuffisamment contrôlée des attributs de prototype d’objet
• MDN — accesseur Object.prototype.__proto__