Análise CVE 2022-22965_Spring4Shell

Descrição da vulnerabilidade

Spring4Shell é o nome de um CVE que existe no Spring Core do Spring Framework.

Com pontuação CVSS 3.x de 9.8, a vulnerabilidade é classificada como de risco máximo (crítica). Esta vulnerabilidade permite que um invasor execute código de exploração remotamente e controle o servidor que contém a vulnerabilidade.

Junto com a popularidade do Spring Core na internet e a gravidade do impacto do Spring4Shell, esta vulnerabilidade é avaliada por especialistas como tendo um impacto não inferior ao Log4shell.

Escopo de impacto

O Spring4Shell não afeta todas as aplicações web que usam o Spring Framework na internet, mas requer que a aplicação web atenda aos seguintes critérios:

• Aplicação usando Spring Framework versão < 5.2, 5.2.0 – 5.2.19 ou 5.3.0 - 5.3.17
• Aplicação que usa uma das dependências Spring-webmvc ou Spring-webflux
• Aplicação usando Java com JDK versão >= 9
• Aplicação empacotada como um arquivo Java web tradicional (arquivo .war) e implantada no Tomcat (a vulnerabilidade não foi detectada em aplicações executadas com Springboot)

Configuração do ambiente

Meu ambiente de configuração terá os seguintes parâmetros:

• Spring Framework 5.1.0
• Spring-webmvc dependency 5.1.0
• JDK 11.0.13 (estou usando uma máquina virtual Kali 2021.4a e esta versão do Java é a instalada por padrão)
• Apache Tomcat 9.0.45

Criar ambiente, projeto com a vulnerabilidade e configurar debug com Intellij

1. Instalação do Apache Tomcat

   Como mencionado acima, estou usando Kali 2021.4a e Apache Tomcat 9.0.45. Se você não sabe como instalar o Apache Tomcat e deseja instalá-lo no Kali Linux, pode consultar este link.

   Nota: Substitua o link https://mirror.kiu.ac.ug/apache/tomcat/tomcat-9/v9.0.45/bin/apache-tomcat-9.0.45.tar.gz por https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.45/bin/apache-tomcat-9.0.45.tar.gz

2. Escolha da IDE

   Precisamos de uma IDE para codificar o projeto, empacotá-lo como um arquivo .war e, muito importante, depurar. Eu uso Intellij, você pode usar Eclipse ou Netbeans, etc., desde que a IDE suporte Java.

3. Criar um projeto simples com a vulnerabilidade

   Meu projeto é muito simples, composto por:

   • um modelo HelloWorld.java

     

   • um controller HelloWorldController.java

     

   • uma view hello.jsp

     

4. Construir o arquivo .war

   Para empacotar o projeto, faça: Build -> Build Artifacts -> helloworld:war -> Build.

   Aguarde a conclusão bem-sucedida da construção. Neste momento, o projeto terá uma pasta out adicional. Vá para ./out/artifacts/your_war_name/ e verá um arquivo your_war_name.war. Este arquivo .war é o projeto web após compilação e empacotamento, e pode ser usado para implantação em servlets Java como Apache Tomcat.

   Se a opção Build Artifacts estiver desabilitada (não é possível construir artefatos), é porque o Build Artifacts não foi configurado para este projeto. Vá em: File -> Project Structure -> Artifacts -> Delete todos os artefatos existentes -> Add (sinal de +) -> Web Application: Exploded -> From Modules... -> OK (finalizar criação do Exploded) -> Add (sinal de +) -> Web Application: Archive -> For 'helloworld:war exploded' -> OK. Depois execute Build Artifacts novamente.

5. Implantação e configuração de debug

   • Implantação

     Para implantar um arquivo .war no Apache Tomcat, basta copiar o arquivo .war para a pasta /webapps dentro do diretório do Apache Tomcat (exemplo: para mim, copio o arquivo helloworld.war (renomeei para facilitar) para /opt/tomcat/apache-tomcat-9.0.45/webapps/). Depois, inicie o servidor Tomcat de duas maneiras (para Linux):

     • /opt/tomcat/apache-tomcat-9.0.45/bin/catalina.sh start (a aplicação será executada com os direitos do usuário que executou o comando; no meu caso, root@@)
     • sudo service tomcat start (a aplicação geralmente será executada com os direitos do usuário tomcat, dependendo de como você configurou o serviço ao instalar o Apache Tomcat)

     Após a implantação, acesse http://localhost:8080/helloworld

   • Configuração de debug

     Para configurar o debug (remoto) do Tomcat, siga os passos abaixo:

     1. Lado do servidor:

        • abra o arquivo catalina.sh e substitua o valor localhost pelo ip_da_maquina_virtual do parâmetro JPDA_ADDRESS

          

        • inicie o servidor Tomcat novamente com: /opt/tomcat/apache-tomcat-9.0.45/bin/catalina.sh jpda start. Neste momento, além de abrir a porta 8080 para o servidor HTTP, o Tomcat abrirá a porta 8000 para podermos conectar e depurar

        Nota: Nesta parte de debug, estou executando o Intellij no Windows 10 e o Tomcat em uma máquina virtual Kali, por isso precisei alterar o JDPA_ADDRESS. Se você configurar tanto o Intellij quanto o Windows 10 na mesma máquina, não precisa alterar.

     2. Lado do Intellij:

        • vá em Run -> Edit Configurations... -> Add (sinal de +) -> Remote JVM Debug

        • Defina um nome, ajuste Host e Port para o IP e porta que você alterou no arquivo catalina.sh -> OK -> Shift + F9 (iniciar debug)

          

Análise detalhada

Primeiramente, vou analisar o projeto que estou usando para depuração. Como mencionado acima, este projeto é simples, consistindo em:

• Um modelo HelloWorld.java, onde o objeto HelloWorld tem dois atributos: message (string), person (string) e métodos setter/getter (por ter estrutura simples, esse objeto é chamado de Plain Old Java Object - POJO). O projeto deve ter uma classe POJO - Esta é uma condição necessária para explorar a vulnerabilidade Spring4Shell.
• Um controller HelloWorldController.java, onde há um método helloPost que recebe como parâmetros um objeto helloWorld (HelloWorld) e um model (Model). No método helloPost, é feito addAttribute ao model a partir dos valores dos atributos de helloWorld (person e message) - A segunda condição para explorar o Spring4Shell é ter um controller que receba um objeto POJO como entrada.
• Uma view hello.jsp, que chama os atributos do model (enviados do controller HelloWorldController.java) e os exibe para o usuário.

Aqui está um exemplo: