prototype-pollution

Detect prototype pollution vulnerabilities in JavaScript via targeted payloads.

2|Updated May 15, 2026
One-click install
npx skills add https://github.com/lNwNl/Methodos --skill prototype-pollution-lnwnl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: prototype-pollution
Source: https://github.com/lNwNl/Methodos/tree/main/docker/opencode/skills/prototype-pollution
Command: npx skills add https://github.com/lNwNl/Methodos --skill prototype-pollution-lnwnl

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Prototype pollution tests identify whether untrusted input can corrupt JavaScript object prototypes, enabling logic manipulation and potential RCE/SSRF-like gadget execution when polluted properties are later consumed.

Core Features & Use Cases

  • Client-side and server-side probes: Generate focused payloads for query/body/fragment parsing and validate global side effects after the initial request.
  • Mechanism coverage: Distinguish and test __proto__ and constructor.prototype pollution paths, including bypasses that miss only one key variant.
  • Gadget-driven exploitation guidance: Map observed pollution to likely sinks and gadget patterns (e.g., template/options, expression chains, child_process-style option usage).
  • Priority decisioning: Suggest when to escalate likelihood based on deep merges, recursive assignment, and nested key handling in common libraries.

Quick Start

Test prototype pollution against an authorized JavaScript target by sending a JSON payload containing __proto__ and then issuing a clean follow-up request to check whether unrelated behavior changes persist.

Frequently Asked Questions about prototype-pollution

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I test for prototype pollution in JavaScript applications?

Test JavaScript prototype pollution by sending payloads containing __proto__ or constructor.prototype via query-string parsing, JSON bodies, or deep merge functions, then issuing a clean follow-up request to verify if global side effects persist.

What causes prototype pollution during deep merge operations?

Prototype pollution occurs during deep merge operations when untrusted input with recursive assignment of nested keys is merged into JavaScript objects, corrupting object prototypes and enabling logic manipulation or RCE gadget execution.

How do I verify if a prototype pollution vulnerability leads to remote code execution?

Verify remote code execution by mapping observed prototype pollution to likely polluted sinks and gadget patterns, such as template options, expression chains, or child_process-style option usage within the JavaScript application framework.

Does query-string parsing expose my application to prototype pollution risks?

Query-string parsing exposes applications to prototype pollution risks when untrusted input is recursively assigned into objects via deep assign, allowing __proto__ or constructor.prototype keys to corrupt JavaScript object prototypes.

What is the difference between __proto__ and constructor.prototype pollution paths?

The difference between __proto__ and constructor.prototype pollution paths lies in the specific JavaScript object prototype chains targeted, and bypasses may miss one key variant, requiring separate testing for comprehensive vulnerability coverage.

When should I escalate prototype pollution likelihood during security testing?

Escalate prototype pollution likelihood during security testing when observing deep merges, recursive assignment, and nested key handling in common JavaScript libraries, as these mechanisms indicate higher probability of untrusted input corrupting object prototypes.