Contaminación de Prototype: La Vulnerabilidad de JavaScript que Envenena Toda tu App ☣️

En el mundo de la seguridad en aplicaciones web, algunas vulnerabilidades se anuncian con caídas dramáticas o brechas evidentes. Otras trabajan en silencio, corrompiendo tu aplicación desde sus cimientos. La contaminación de prototype pertenece a esta última categoría, una vulnerabilidad sutil pero devastadora que explota la herencia prototípica de JavaScript para envenenar cada objeto en tu aplicación con una sola entrada maliciosa.

Entendiendo la Cadena de Prototype en JavaScript

Antes de profundizar en el ataque, necesitamos entender cómo funciona la herencia basada en prototypes en JavaScript. A diferencia de los lenguajes orientados a objetos clásicos, JavaScript usa prototypes para compartir propiedades y métodos entre objetos. Cada objeto en JavaScript tiene un enlace interno a otro objeto llamado su prototype, formando lo que se conoce como la cadena de prototype.

Cuando accedes a una propiedad en un objeto, JavaScript primero verifica si esa propiedad existe directamente en el objeto. Si no, recorre la cadena de prototype, verificando cada prototype hasta que encuentra la propiedad o llega al final de la cadena en Object.prototype. Este mecanismo elegante permite compartir propiedades de manera eficiente, pero también crea una superficie de ataque peligrosa.

Considera este código aparentemente inocente:

const user = { name: 'Alice' };
console.log(user.toString); // [Function: toString]

Aunque nunca definimos una propiedad toString en el objeto user, JavaScript la encuentra al recorrer la cadena de prototype hasta Object.prototype, donde toString está definido. Este comportamiento es fundamental en JavaScript, pero se vuelve peligroso cuando atacantes pueden manipular estos prototypes.

¿Qué es la Contaminación de Prototype?

La contaminación de prototype es una vulnerabilidad que permite a los atacantes inyectar propiedades en los prototypes de constructos del lenguaje JavaScript, explotando el hecho de que JavaScript permite modificar todos los atributos de los objetos, incluyendo propiedades especiales como __proto__, constructor y prototype.

El ataque funciona explotando cómo JavaScript maneja la asignación de propiedades en objetos. Cuando una aplicación combina datos controlados por el usuario en objetos existentes sin validación adecuada, un atacante puede crear una entrada maliciosa que modifica el Object.prototype base. Dado que virtualmente todos los objetos en JavaScript heredan de Object.prototype, esta modificación afecta toda la aplicación.

Estas vulnerabilidades suelen surgir cuando funciones en JavaScript combinan recursivamente objetos que contienen propiedades controladas por el usuario en objetos existentes sin sanitizar primero las claves, especialmente al procesar datos JSON de fuentes no confiables.

La Anatomía de un Ataque de Contaminación de Prototype

Veamos cómo funciona un ataque real de contaminación de prototype usando una función de merge vulnerable, similar a las encontradas en librerías populares. Aquí un ejemplo simplificado:

function merge(target, source) {
  for (let key in source) {
    if (typeof source[key] === 'object') {
      if (!target[key]) target[key] = {};
      merge(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}

// Uso normal
const user = {};
merge(user, { name: 'Alice', role: 'user' });
console.log(user); // { name: 'Alice', role: 'user' }

Esta función parece inofensiva. Recursivamente combina propiedades de un objeto fuente en un objetivo. Sin embargo, observa qué sucede cuando un atacante proporciona una entrada maliciosa:

// Payload malicioso
const maliciousInput = JSON.parse('{"__proto__": {"isAdmin": true}}');

// Contaminar el prototype
merge({}, maliciousInput);

// Ahora CADA objeto tiene la propiedad isAdmin
const normalUser = {};
console.log(normalUser.isAdmin); // true - ¡contaminación exitosa!

El atacante explotó la propiedad especial __proto__ para acceder a Object.prototype e inyectar una propiedad isAdmin. Ahora, todos los objetos en la aplicación, incluyendo los nuevos objetos creados que nunca han estado cerca de la función de merge, heredan esta propiedad envenenada.

Impacto en el Mundo Real: El Caso de Lodash

La librería Lodash, muy popular, ha sido afectada por vulnerabilidades de contaminación de prototype en funciones como defaultsDeep, merge, y mergeWith, que permiten a usuarios maliciosos modificar el prototype de Object vía __proto__, afectando potencialmente a millones de aplicaciones en todo el mundo.

Considera este código vulnerable usando la función merge de Lodash:

const _ = require('lodash');
const express = require('express');
const app = express();
app.use(express.json());

app.post('/api/update-settings', (req, res) => {
  const userSettings = {};
  // Vulnerable: fusionando entrada no confiable del usuario
  _.merge(userSettings, req.body);
  
  // Más adelante en la aplicación
  if (userSettings.isAdmin) {
    // Conceder acceso de administrador
    return res.json({ access: 'admin' });
  }
  res.json({ access: 'user' });
});

Un atacante podría enviar esta carga útil:

{
  "__proto__": {
    "isAdmin": true
  }
}

Esta sola petición envenena el prototype, y de repente, cada objeto en la aplicación, incluyendo aquellos usados para verificaciones de autorización, hereda la propiedad isAdmin configurada en true. El impacto se propaga por toda la aplicación.

De Contaminación a Ejecución Remota de Código

Las consecuencias de la contaminación de prototype van mucho más allá de la escalada de privilegios simple. En entornos Node.js, atacantes habilidosos pueden encadenar contaminación de prototype con otras vulnerabilidades para lograr ejecución remota de código (RCE). Esto sucede mediante técnicas llamadas “gadget chains”, donde las propiedades envenenadas interactúan con rutas de código existentes de maneras inesperadas.

Por ejemplo, si una aplicación usa spawn de procesos hijos y depende de propiedades heredadas para construir comandos, un atacante podría inyectar comandos maliciosos mediante contaminación de prototype:

// Código vulnerable
const { spawn } = require('child_process');

function executeCommand(options) {
  const defaultOptions = {};
  // Las opciones podrían heredar propiedades contaminadas
  const finalOptions = Object.assign(defaultOptions, options);
  
  spawn('node', [finalOptions.script || 'default.js'], {
    shell: finalOptions.shell || false,
    env: finalOptions.env || process.env
  });
}

Si un atacante contamina el prototype con {"shell": true, "script": "; malicious-command"}, podría lograr ejecución de código cuando esta función se ejecute con verificaciones de propiedades insuficientes.

Cross-Site Scripting a través de Contaminación de Prototype

Los atacantes pueden contaminar prototypes con propiedades como innerHTML, src, o onerror, y si la aplicación referencia estas propiedades y las inserta en el DOM, el XSS se vuelve posible. Esta variante es particularmente peligrosa en frameworks JavaScript del lado del cliente:

// Renderizado vulnerable
function renderContent(element, data) {
  element.innerHTML = data.content || 'Contenido por defecto';
}

// El atacante contamina el prototype
const malicious = JSON.parse('{"__proto__": {"content": "<img src=x onerror=alert(document.cookie)>"}}');
merge({}, malicious);

// Más adelante en el código
const emptyData = {};
renderContent(document.getElementById('output'), emptyData);
// ¡XSS activado mediante prototype contaminado!

Detección en el Mundo Real

Investigadores usando técnicas avanzadas de fuzzing han descubierto 65 nuevas vulnerabilidades de contaminación de prototype en escenarios zero-day que no pudieron ser detectadas por métodos tradicionales, resaltando cuán extendido sigue este problema. El desafío con la contaminación de prototype es su sutileza. A diferencia de inyecciones SQL o XSS, que a menudo producen errores inmediatos o efectos visibles, la contaminación de prototype puede permanecer en silencio en tu base de código, esperando las condiciones adecuadas para causar fallos catastróficos.

Programación Defensiva: Construyendo Aplicaciones Resistentes a la Contaminación

Proteger tu aplicación contra la contaminación de prototype requiere un enfoque en capas combinando prácticas de codificación seguras, validación de entrada y decisiones arquitectónicas.

Usa Object.create(null) para Diccionarios

Usar objetos sin prototypes, creados con Object.create(null), rompe la cadena de prototype y previene la contaminación. Esta es una de las defensas más efectivas:

// Seguro: Sin cadena de prototype
const userSettings = Object.create(null);
userSettings.name = 'Alice';

// No puede ser contaminado
const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
Object.assign(userSettings, malicious);
console.log(userSettings.isAdmin); // undefined - protegido!

Los objetos creados de esta manera no tienen prototype, haciéndolos inmunes a ataques de contaminación de prototype. Usa este patrón para cualquier objeto que contendrá datos controlados por el usuario.

Implementa Validación y Sanitización de Propiedades

Siempre valida y sanitiza las claves de los objetos antes de procesar la entrada del usuario:

function secureMerge(target, source) {
  const dangerousKeys = ['__proto__', 'constructor', 'prototype'];
  
  for (let key in source) {
    // Bloquea claves peligrosas
    if (dangerousKeys.includes(key)) {
      continue;
    }
    
    // Validación adicional
    if (typeof key !== 'string' || key.startsWith('_')) {
      continue;
    }
    
    if (typeof source[key] === 'object' && source[key] !== null) {
      if (!target[key]) target[key] = Object.create(null);
      secureMerge(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}

Usa Object.freeze() para Objetos Críticos

Congela prototypes y objetos críticos para evitar modificaciones:

// Previene contaminación de prototype en la raíz
Object.freeze(Object.prototype);
Object.freeze(Object);

// Congela objetos de configuración
const config = Object.freeze({
  apiUrl: 'https://api.ejemplo.com',
  timeout: 5000
});

Aunque este método es efectivo, ten cuidado ya que puede romper código legítimo que dependa de modificaciones en prototypes. Úsalo selectivamente en objetos críticos para la seguridad.

Prefiere Map en Lugar de Objetos Planos

Como buena práctica, usa Map en lugar de Object para almacenar pares clave-valor, ya que los Maps no heredan de Object.prototype:

// Alternativa segura a objetos
const userSettings = new Map();
userSettings.set('name', 'Alice');
userSettings.set('role', 'user');

// No vulnerable a contaminación de prototype
console.log(userSettings.get('isAdmin')); // undefined

Los Maps ofrecen una API más limpia para almacenamiento clave-valor y eliminan completamente los riesgos de contaminación de prototype.

Implementa Validación de Esquemas

Usa librerías de validación de esquemas para hacer cumplir estructuras estrictas en los objetos:

const Joi = require('joi');

const userSchema = Joi.object({
  name: Joi.string().required(),
  email: Joi.string().email().required(),
  role: Joi.string().valid('user', 'admin').required()
}).unknown(false); // Rechaza propiedades desconocidas

app.post('/api/users', (req, res) => {
  const { error, value } = userSchema.validate(req.body);
  if (error) {
    return res.status(400).json({ error: error.details });
  }
  // Es seguro usar los datos validados
  processUser(value);
});

La validación de esquemas asegura que solo las propiedades esperadas lleguen a la lógica de tu aplicación, bloqueando intentos de contaminación de prototype en el punto de entrada.

Actualiza Dependencias Regularmente

Mantén tus dependencias actualizadas, especialmente librerías críticas en seguridad. Las versiones modernas de librerías populares como Lodash han abordado vulnerabilidades de contaminación de prototype, pero solo si usas versiones recientes. Usa herramientas como npm audit o Snyk para identificar dependencias vulnerables:

npm audit
npm audit fix

Habilita Modo Estricto

El modo estricto de JavaScript ofrece protecciones adicionales:

'use strict';

// El modo estricto previene la creación accidental de variables globales
// y hace que algunos errores silenciosos lancen excepciones
function processData(input) {
  // Entorno de ejecución más seguro
}

Pruebas de Contaminación de Prototype

Incluye pruebas de contaminación de prototype en tu suite de pruebas de seguridad:

describe('Pruebas de Contaminación de Prototype', () => {
  it('no debe contaminar Object.prototype', () => {
    const original = Object.prototype.toString;
    
    // Intento de contaminación
    const malicious = { "__proto__": { "isAdmin": true } };
    merge({}, malicious);
    
    // Verifica que no ocurrió contaminación
    const testObj = {};
    expect(testObj.isAdmin).toBeUndefined();
    expect(Object.prototype.toString).toBe(original);
  });
  
  it('debe rechazar __proto__ en entrada JSON', () => {
    const input = '{"__proto__": {"polluted": true}}';
    const result = safeJSONParse(input);
    
    expect({}.polluted).toBeUndefined();
  });
});

La Visión General: Seguro por Defecto

La contaminación de prototype ejemplifica un principio más amplio en la seguridad de aplicaciones: defensa en profundidad. Ninguna técnica elimina completamente el riesgo. En cambio, apila múltiples estrategias defensivas:

1. Usa objetos sin prototype (Object.create(null)) para datos del usuario
2. Valida y sanitiza toda entrada, especialmente claves de objetos
3. Congela objetos y prototypes críticos
4. Prefiere Map en lugar de objetos planos para diccionarios
5. Implementa validación estricta de esquemas
6. Mantén actualizadas las dependencias
7. Realiza pruebas de seguridad regulares
8. Monitorea patrones de acceso inusuales en producción

Conclusión

La contaminación de prototype demuestra cómo una característica aparentemente inocua del lenguaje puede convertirse en una vulnerabilidad de seguridad grave al manejar entrada no confiable. Al explotar la cadena de prototype de JavaScript, los atacantes pueden inyectar propiedades que envenenan cada objeto en tu aplicación, llevando a escalada de privilegios, denegación de servicio o incluso ejecución remota de código.

La buena noticia es que la contaminación de prototype es prevenible mediante prácticas de codificación disciplinadas. Al entender el vector de ataque, implementar validación robusta de entrada, usar patrones de creación de objetos más seguros y mantener dependencias actualizadas, puedes construir aplicaciones JavaScript que resistan esta vulnerabilidad sutil pero devastadora.

Recuerda: en JavaScript, tu aplicación solo es tan segura como su cadena de prototype. Un prototype contaminado puede envenenar toda tu app, pero con las estrategias defensivas correctas, puedes asegurar que tus objetos permanezcan puros y tu aplicación segura.