Nuevos labs cada semana — Accede a todos desde 7,99€/mes

Labs de Prototype Pollution

Prototype Pollution

¿Qué es Prototype Pollution?

El Prototype Pollution es una vulnerabilidad de JavaScript en la que el atacante inyecta propiedades en Object.prototype a través de claves como __proto__ o constructor.prototype. Contamina todos los objetos del runtime y, con el gadget adecuado, escala a XSS en cliente o a RCE en Node.js.

¿Por qué practicar Prototype Pollution?

Es una clase moderna y poco entendida que afecta a librerías ultra-populares (lodash, jQuery, query parsers). Encadenada con un gadget, pasa de 'propiedad rara' a XSS o RCE real. Encontrarla requiere leer JS y entender el runtime, así que hay menos competencia y bounties de $1,000-$20,000.

¿Qué aprenderás con los labs de Prototype Pollution?

Aprenderás a detectar funciones de merge/clone/extend que copian recursivamente input del usuario, inyectar __proto__/constructor.prototype vía JSON o query string, confirmar la contaminación, y buscar gadgets explotables tanto en cliente (sinks DOM) como en servidor (child_process, template engines).

Tipos de Prototype Pollution que cubrimos

Client-side
Polución en JS de navegador (query string, postMessage) que un gadget convierte en DOM XSS.
Server-side (Node.js)
Polución en una API Node que, con gadget (spawn, require, render), escala a RCE.
Vía query string parser
Parsers como qs interpretan a[__proto__][x]=y y contaminan el prototipo sin que envíes JSON.

¿Cómo encontrar y explotar Prototype Pollution?

Playbook práctico — del recon a la prueba de concepto.

1
Encontrar el merge recursivo
Busca en el JS funciones que copian objetos en profundidad (merge, extend, clone, defaultsDeep) alimentadas por input del usuario.
```
merge(target, JSON.parse(req.body))   ·   lodash.merge, $.extend(true, ...)
```
2
Inyectar __proto__
Manda un payload con __proto__ o constructor.prototype para añadir una propiedad al prototipo global.
```
{"__proto__":{"polluted":"yes"}}
```
3
Confirmar la contaminación
Comprueba que un objeto recién creado hereda tu propiedad. En cliente, desde consola; en servidor, por una respuesta que la refleje.
```
({}).polluted   →   "yes"   (la polución funcionó)
```
4
Inyectar vía query string
Si el backend usa qs/Express, contamina sin JSON usando notación de corchetes en la URL.
```
?__proto__[polluted]=yes   ·   ?constructor[prototype][polluted]=yes
```
5
Encadenar con un gadget
Busca un gadget que lea una propiedad heredada: en cliente puede activar un sink DOM (XSS); en Node, opciones de spawn/render para RCE.
```
Cliente: __proto__.src → XSS  ·  Node: __proto__.shell + child_process → RCE
```

Aprende la teoría

Academy: Técnicas Avanzadas

Cargando labs...

Ver en catálogo completo →

Preguntas frecuentes

¿Qué es el Prototype Pollution?

Es una vulnerabilidad de JavaScript en la que se inyectan propiedades en Object.prototype mediante claves como __proto__ o constructor.prototype. Como todos los objetos heredan del prototipo, la contaminación afecta a todo el runtime y puede escalar a XSS o RCE con el gadget adecuado.

¿Cómo se explota el Prototype Pollution?

Se envía un payload con __proto__ a una función que hace merge/clone recursivo del input (lodash.merge, $.extend). Tras contaminar el prototipo, se busca un gadget que lea esa propiedad heredada: en cliente activa un sink DOM (XSS), en Node opciones de spawn/render (RCE).

¿Cómo encontrar Prototype Pollution en bug bounty?

Lee el JavaScript en busca de merges profundos de objetos controlados por el usuario, e inyecta __proto__ vía JSON o query string (?__proto__[x]=y). Confirma con ({}).x y luego invierte tiempo en encontrar un gadget que convierta la polución en impacto.

¿Cómo prevenir el Prototype Pollution?

Rechaza claves __proto__/constructor/prototype al parsear, usa Object.create(null) o Map para datos sin prototipo, congela Object.prototype (Object.freeze), valida con esquemas estrictos y mantén actualizadas las librerías de merge/clone.

¿Por qué el Prototype Pollution suele necesitar un gadget?

Porque contaminar el prototipo por sí solo no hace nada visible: añade una propiedad heredada. El impacto llega cuando otro trozo de código lee esa propiedad sin esperarlo (un 'gadget') y la usa en un sink peligroso, transformando la polución en XSS o RCE.

Otras categorías relacionadas

XSS

Cross-Site Scripting (XSS)

Command Injection

OS Command Injection

Deserialización

Insecure Deserialization

→ Ver todas las vulnerabilidades → Academy gratuita → Precios desde 7,99€/mes

Empieza con labs de Prototype Pollution

Practica Prototype Pollution con labs basados en reportes reales. En español. Desde 7,99€/mes.

Empieza con el primer lab de Prototype Pollution