JavaScript Object Prototype Pollution Defense in Deep Merge Functions

--- description: JavaScript Object Prototype Pollution Defense in Deep Merge Functions - Production JavaScript/TypeScript security standard (CWE-1321). Mandates blocking __proto__, constructor, and prototype property keys in recursive deep merge and object clone functions, eliminating prototype pollution attacks that lead to Remote Code Execution (RCE) or authentication bypass. globs: **/utils/**/*.ts, **/merge*.ts, **/clone*.js alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/prototype-pollution-recursive-merge" --- # JavaScript Object Prototype Pollution Defense in Deep Merge Functions > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: AI writes naive recursive object merge functions that traverse __proto__ keys, polluting the global Object.prototype across the entire Node.js runtime. ## System Constraints You are a Node.js Application Security Specialist. When authoring recursive object merging, copying, or patch functions, NEVER iterate over object keys without filtering forbidden dangerous prototype properties (__proto__, constructor, prototype). Allowing attackers to set payload['__proto__']['isAdmin'] = true corrupts all objects in the Node.js process. ## Strict Guidelines - MUST sanitize keys and skip '__proto__', 'constructor', and 'prototype' in any recursive merge loop. - MUST use Object.create(null) for dictionary maps requiring zero prototype inheritance. - MUST use Object.hasOwn(obj, key) or Object.prototype.hasOwnProperty.call(obj, key) rather than obj.hasOwnProperty(). - SHOULD use structuredClone() for pure data object cloning where prototype inheritance is not desired. - SHOULD freeze shared global options (Object.freeze(options)) to prevent tampering. ## Bad vs Good Implementations ### Safe Deep Merge Function Defending Against Prototype Pollution #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Supplying JSON with {"__proto__": {"isAdmin": true}} injects the isAdmin property into every object created across the entire application runtime. ```typescript // FATAL: Naive deep merge vulnerable to Prototype Pollution (CWE-1321) function badDeepMerge(target: any, source: any) { for (const key in source) { if (typeof source[key] === 'object' && source[key] !== null) { if (!target[key]) target[key] = {}; // VULNERABLE: If key is '__proto__', modifies Object.prototype for ALL objects in Node.js! badDeepMerge(target[key], source[key]); } else { target[key] = source[key]; } } return target; } ``` #### Production Standard (Correct) > **Standard**: Explicitly blocks __proto__, constructor, and prototype keys, and initializes child records with Object.create(null) to prevent runtime prototype pollution. ```typescript const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']); export function safeDeepMerge<T extends Record<string, any>>(target: T, source: Record<string, any>): T { for (const key of Object.keys(source)) { // 1. Defense: Drop dangerous prototype pollution keys immediately if (FORBIDDEN_KEYS.has(key)) { continue; } const srcVal = source[key]; if (srcVal && typeof srcVal === 'object' && !Array.isArray(srcVal)) { if (!target[key] || typeof target[key] !== 'object') { target[key as keyof T] = Object.create(null); } safeDeepMerge(target[key], srcVal); } else { target[key as keyof T] = srcVal; } } return target; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: JavaScript Object Prototype Pollution Defense in Deep Merge Functions

JavaScript Object Prototype Pollution Defense in Deep Merge Functions defines an industrial-grade behavioral standard for security engineering. Production JavaScript/TypeScript security standard (CWE-1321). Mandates blocking __proto__, constructor, and prototype property keys in recursive deep merge and object clone functions, eliminating prototype pollution attacks that lead to Remote Code Execution (RCE) or authentication bypass. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: AI writes naive recursive object merge functions that traverse __proto__ keys, polluting the global Object.prototype across the entire Node.js runtime. Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	AI writes naive recursive object merge functions that traverse __proto__ keys, polluting the global Object.prototype across the entire Node.js runtime.	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

MUST sanitize keys and skip 'proto', 'constructor', and 'prototype' in any recursive merge loop.

MUST sanitize keys and skip '__proto__', 'constructor', and 'prototype' in any recursive merge loop.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.