Verificações de vulnerabilidade do OWASP com o Maven

Embora muitos de nós tomem medidas ativas ao desenvolver nossos projetos, para proteger contra vulnerabilidades de segurança conhecidas, há uma série de ações e verificações passivas que geralmente são negligenciadas.

Utilizar bibliotecas de terceiros pode aumentar consideravelmente a produtividade da equipe e permitir desenvolver softwares melhores, mas isso sempre introduz um risco. Será que alguma dependência do seu projeto contém falhas de segurança conhecidas? Este é um dos fatores que temos que nos preocupar continuamente durante o desenvolvimento e manutenção dos nossos sistemas.

O Open Web Application Security Project (OWASP) é uma fundação sem fins lucrativos que trabalha para melhorar a segurança do software. O OWASP emite e mantém várias recomendações sobre como escrever código seguro e é mantida por uma  variedade de empresas como: Accenture, Adobe, Acunetix, Dell, entre outras.

Um dos projetos executados pelo OWASP é o OWASP Dependency-Check .
A Verificação de Dependência é uma ferramenta de Análise de Composição de Software (SCA – Software Composition Analysis) que tenta detectar vulnerabilidades divulgadas publicamente contidas nas dependências de um projeto. Ele faz isso determinando se existe um identificador CPE (Common Platform Enumeration) para uma determinada dependência. Se encontrado, ele gerará um relatório vinculado às entradas associadas do CVE.

Nesta parte, mostrarei como integrar rapidamente o OWASP Dependency-Check em seu projeto Java/Maven.

Verificando as dependências

O Dependency-check-maven é muito simples de utilizar e pode ser usado como um plug-in independente ou como parte do plug-in do site. O plug-in requer o Maven 3.1 ou superior.

Vamos criar um projeto de exemplo:

mvn -B archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DgroupId=br.com.teste.app \
  -DartifactId=my-app

Você pode executar a verificação sem fazer qualquer alteração no projeto usando o comando:

mvn org.owasp:dependency-check-maven:check

Caso queria ignorar as dependências Provided e/ou Runtime basta adicionar respectivamente os parâmetros -DskipProvidedScope=true e/ou -DskipRuntimeScope=true

Vamos ver agora o mesmo comportamento do comando acima, porém vamos modificar o projeto e criar um profile. Por que um profile? Pois não queremos que a cada compilação que você executar durante o desenvolvimento a verificação seja feita.

Nosso pom.xml ficaria assim:

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>br.com.teste.app</groupId>
    <artifactId>my-app</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>my-app</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <profiles>
        <profile>
            <id>owasp-dependency-check</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.owasp</groupId>
                        <artifactId>dependency-check-maven</artifactId>
                        <version>5.3.2</version>
                        <configuration>
                            <skipProvidedScope>true</skipProvidedScope>
                            <skipRuntimeScope>true</skipRuntimeScope>
                        </configuration>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>check</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

Agora você pode executar as verificações em sua compilação usando o profile:

mvn clean install -Powasp-dependency-check

Como é a primeira vez que você executa a verificação de dependência, será necessário algum tempo para buscar o banco de dados de vulnerabilidades e armazená-lo localmente. Isso pode levar de 5 a 20 minutos (sujeito à velocidade da sua conexão com a Internet), mas acontece apenas uma vez. As compilações subsequentes buscarão apenas atualizações e, portanto, serão consideravelmente mais rápidas.

No final da saída do Maven, você deve ver a saída da análise de vulnerabilidade:

dependency-check-maven

Obviamente, a análise não encontrou nenhuma vulnerabilidade, pois nenhuma dependência externa (além da owasp-dependency-check) foi adicionada ao projeto.

Você pode encontrar outra formas de configurar seu projeto aqui.

Hora de introduzir algum código vulnerável.

Introduzindo código vulnerável

A principal fonte de vulnerabilidades para a verificação de dependência é o National Vulnerability Database (NVD). Vamos navegar pela lista de Vulnerabilidades e exposições comuns (CVEs) abertas para obter relatórios relacionados ao Spring :

Há muito o que escolher, então vamos escolher um e adicionar ao nosso pom.xml. Vamos para o artefato do Spring Security Core, versão 5.1.10.RELEASE .

<!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-core -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-core</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

Executando o nosso código mais uma vez, agora com a dependência:

mvn clean install -Powasp-dependency-check
[WARNING] 

One or more dependencies were identified with known vulnerabilities in my-app:

spring-security-core-5.1.10.RELEASE.jar (pkg:maven/org.springframework.security/spring-security-core@5.1.10.RELEASE, cpe:2.3:a:pivotal_software:spring_security:5.1.10:release:*:*:*:*:*:*) : CVE-2018-1258

See the dependency-check report for more details.

O plugin Dependency-Check identificou com sucesso a dependência do Spring que introduzimos e relatou as vulnerabilidades conhecidas sobre ele. 

Gerando um relatório HTML

Se você preferir procurar as vulnerabilidades detectadas no seu navegador em vez da CLI, o Dependency-Check cria um relatório HTML dentro da sua pasta target chamada dependency-check-report.html:

O relatório contém muitas informações com links para o NVD para obter detalhes adicionais.

Conclusão

As vulnerabilidades do código fonte são uma ameaça muito real ao seu projeto. A menos que você tenha um sistema instalado para monitorar automaticamente seu projeto quanto a vulnerabilidades, é mais provável que em algum momento você apresente uma dependência vulnerável de terceiros.

Introduzir o Dependency-Check em seus projetos Maven leva apenas alguns minutos. Sugiro que você gaste alguns minutos extras hoje e altere seu pom.xmlpara incluí-lo. Eu garanto que você ficará impressionado com quantas vulnerabilidades não descobertas você pode encontrar.


No próximo artigo mostrarei como fazer a verificação em projetos JavaScript.
Obrigado por ler. Espero vê-lo no próximo.