# XSS (Cross Site Scripting)
/
**Dica de recompensa por bug**: **inscreva-se** no **Intigriti**, uma plataforma premium de recompensas 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 Pendurada - 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 a 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 sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `` e escapar deste 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)}` ``
* **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 que elas são usadas**.
Portanto, se você tiver cenários em que pode **injetar código JS depois que um objeto não declarado** é 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 'Vulnerável') 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 **Same Origin Method Execution (SOME)**:
{% 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 atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.
{% content-ref url="dom-xss.md" %}
[dom-xss.md](dom-xss.md)
{% endcontent-ref %}
### **Universal XSS**
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 do 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 **excluído** ou se ele é **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 lista negra/lista branca, você pode usar payloads como:
```javascript