😎
WEB
YouTubeTwitterLinkedIn
  • La Biblia del Hacking en Web
    • ADVERTENCIA
    • Conoce a tu academia
    • Conoce a tu instructor
    • Aprende Hacking Web con los laboratorios de PortSwigger
  • SQL Injection
    • ¿SQL Injection?
    • Lab 1: SQL injection vulnerability in WHERE clause allowing retrieval of hidden data
    • Lab 2: SQL injection vulnerability allowing login bypass
    • Lab 3: SQL injection attack, querying the database type and version on Oracle
    • Lab 4: SQL injection attack, querying the database type and version on MySQL and Microsoft
    • Lab 5: SQL injection attack, listing the database contents on non-Oracle databases
    • Lab 6: SQL injection attack, listing the database contents on Oracle
  • Cross Site Scripting
    • ¿XSS?
    • Lab 1: Reflected XSS into HTML context with nothing encoded
    • Lab 2: Stored XSS into HTML context with nothing encoded
    • Lab 3: DOM XSS in document.write sink using source location.search
    • Lab 4: DOM XSS in innerHTML sink using source location.search
    • Lab 5: DOM XSS in jQuery anchor href attribute sink using location.search source
  • ClickJacking
    • ¿Clickjacking?
    • Lab 1: Basic clickjacking with CSRF token protection
  • Access control vulnerabilities
    • ¿Control de Acceso?
    • Lab 1: Unprotected admin functionality
    • Lab 3: User role controlled by request parameter
  • Path traversal
    • ¿Path Traversal?
    • Lab 1: File path traversal, simple case
    • Lab 2: File path traversal, traversal sequences blocked with absolute path bypass
    • Lab 3: File path traversal, traversal sequences stripped non-recursively
  • XML external entity (XXE) injection
    • ¿XML external entity?
    • Lab 1: Exploiting XXE using external entities to retrieve files
    • Lab 2: Exploiting XXE to perform SSRF attacks
    • Lab 3: Blind XXE with out-of-band interaction
  • JWT
    • ¿JWT?
    • Lab 1: JWT authentication bypass via unverified signature
    • Lab 2: JWT authentication bypass via flawed signature verification
    • Lab 3: JWT authentication bypass via weak signing key
    • Lab 4: JWT authentication bypass via jwk header injection
    • Lab 5: JWT authentication bypass via jku header injection
  • Server-side request forgery (SSRF)
    • ¿SSRF?
    • Lab 1: Basic SSRF against the local server
  • OS command injection
    • ¿OS Command Injection?
    • Lab 1: OS command injection, simple case
  • Authentication
    • ¿Authentication?
    • Lab 1: Username enumeration via different responses
  • HTTP request smuggling
    • ¿HTTP request smuggling?
    • Lab 1: HTTP request smuggling, confirming a CL.TE vulnerability via differential responses
  • Server-side template injection
    • ¿Server-side template injection?
    • Lab 1: Basic server-side template injection
  • DOM-based vulnerabilities
    • Lab 1: DOM XSS using web messages
    • Lab 2: DOM XSS using web messages and a JavaScript URL
  • WebSockets
    • Lab #1: Manipulating WebSocket messages to exploit vulnerabilities
  • Prototype pollution
    • ¿Prototype Pollution?
    • Lab 1: Client-side prototype pollution via browser APIs
      • Utilizando DOM Invader
    • Lab 2: DOM XSS via client-side prototype pollution
    • Lab 3: DOM XSS via an alternative prototype pollution vector
      • Utilizando DOM Invader
    • Lab 4: Client-side prototype pollution via flawed sanitization
    • Lab 5: Client-side prototype pollution in third-party libraries
    • Lab 6: Privilege escalation via server-side prototype pollution
    • Lab 7: Detecting server-side prototype pollution without polluted property reflection
    • Lab 8: Bypassing flawed input filters for server-side prototype pollution
    • Lab 9: Remote code execution via server-side prototype pollution
    • Lab 10: Exfiltrating sensitive data via server-side prototype pollution
  • GraphQL
    • Lab 1: Accessing private GraphQL posts
  • Web cache poisoning
    • Lab 1: Web cache poisoning with an unkeyed header
  • CORS
    • Lab #2 - CORS vulnerability with trusted null origin
    • Lab 3: CORS vulnerability with trusted insecure protocols
  • API testing
    • Lab #1: Exploiting an API endpoint using documentation
    • Lab #2: Exploiting server-side parameter pollution in a query string
    • Lab #3: Finding and exploiting an unused API endpoint
    • Lab #4: Exploiting a mass assignment vulnerability
    • Lab #5: Exploiting server-side parameter pollution in a REST URL
Con tecnología de GitBook
En esta página
  • ¿Qué es un prototipo en JavaScript?
  • ¿Qué es Prototype Pollution?
  • Ejemplo de Prototype Pollution
  • ¿Por qué surge la vulnerabilidad?
  • Escenarios Comunes Donde Puede Surgir
  • Prevención

¿Te fue útil?

  1. Prototype pollution

¿Prototype Pollution?

La vulnerabilidad Prototype Pollution es una forma de ataque en el cual un atacante puede inyectar propiedades arbitrarias en los prototipos de objetos nativos de JavaScript, lo que puede llevar a la modificación de las propiedades y comportamientos de todos los objetos que heredan de esos prototipos.

¿Qué es un prototipo en JavaScript?

En JavaScript, los objetos pueden heredar propiedades y métodos de un prototipo. Cada objeto tiene un prototipo (accesible a través de __proto__ o Object.getPrototypeOf), y el prototipo a su vez tiene su propio prototipo, formando una cadena de prototipos (prototype chain). Por ejemplo, si se crea un objeto vacío {}, este hereda de Object.prototype.

¿Qué es Prototype Pollution?

Prototype Pollution ocurre cuando un atacante puede modificar el prototipo de objetos nativos, como Object.prototype, Array.prototype, etc., añadiendo o sobrescribiendo propiedades. Esto afecta a todos los objetos que heredan de ese prototipo, lo que puede tener consecuencias devastadoras para la aplicación.

Ejemplo de Prototype Pollution

Consideremos el siguiente ejemplo simplificado:

// Código vulnerable
let params = JSON.parse('{"__proto__": {"polluted": "yes"}}');

// Uso de params en el código
let obj = {};
console.log(obj.polluted); // Output: "yes"

En este ejemplo, params se parsea desde un JSON que contiene la propiedad __proto__. Al asignar este objeto, se modifica el prototipo de todos los objetos, añadiendo una propiedad polluted con el valor "yes". Ahora, cualquier objeto creado en el programa tiene una propiedad polluted con ese valor.

¿Por qué surge la vulnerabilidad?

La vulnerabilidad de Prototype Pollution puede surgir en los siguientes escenarios:

  1. Manipulación Insegura de Objetos: Cuando el código permite a los usuarios o datos externos modificar objetos directamente, sin sanitizar o validar adecuadamente las claves.

  2. Bibliotecas Vulnerables: Algunas bibliotecas pueden manejar de manera insegura la asignación de propiedades en objetos, permitiendo la contaminación de prototipos. Esto es común en bibliotecas que manipulan datos JSON, query strings, etc.

  3. Falta de Sanitización: No filtrar o validar adecuadamente las propiedades de los objetos que se construyen o modifican a partir de datos no confiables.

Escenarios Comunes Donde Puede Surgir

  1. Aplicaciones Web: En aplicaciones web que procesan datos de entrada del usuario, como formularios, parámetros de URL, o datos JSON, un atacante podría enviar datos especialmente diseñados para modificar los prototipos.

  2. APIs: APIs que aceptan y procesan datos JSON de clientes pueden ser vulnerables si no sanitizan adecuadamente las propiedades de los objetos.

  3. Bibliotecas de Terceros: Usar bibliotecas de terceros que no están adecuadamente protegidas contra esta vulnerabilidad puede introducir Prototype Pollution en tu aplicación.

Prevención

Para prevenir la vulnerabilidad de Prototype Pollution, se deben seguir varias prácticas:

  1. Sanitización de Datos: Filtrar y sanitizar las propiedades de los objetos antes de procesarlos. Asegurarse de que los datos no contengan claves peligrosas como __proto__, constructor, prototype.

  2. Validación de Entradas: Implementar una validación estricta de los datos de entrada para asegurarse de que solo las propiedades esperadas sean permitidas.

  3. Uso Seguro de Bibliotecas: Elegir y usar bibliotecas que sean seguras y mantenerlas actualizadas para protegerse contra vulnerabilidades conocidas.

AnteriorLab #1: Manipulating WebSocket messages to exploit vulnerabilitiesSiguienteLab 1: Client-side prototype pollution via browser APIs

Última actualización hace 10 meses

¿Te fue útil?