Como prevenir Cross-Site Scripting (XSS) em aplicações Java com Snyk Code

Java é uma poderosa linguagem de programação de backend que também pode ser usada para criar páginas HTML para aplicações web. No entanto, ao criar essas páginas, os desenvolvedores precisam conhecer os possíveis riscos de segurança associados a ataques de Cross-Site Scripting (XSS). Com o avanço dos frameworks modernos de templates, ficou mais fácil prevenir ataques por meio de técnicas adequadas de validação e codificação de entradas. Porém, quando os desenvolvedores decidem criar suas próprias páginas HTML sem usar um framework de templates, o risco de introduzir vulnerabilidades aumenta.

Por exemplo, usar o objeto HttpServletResponse em uma aplicação Spring MVC para gravar conteúdo diretamente na resposta pode permitir que usuários mal-intencionados injetem código na página, levando a possíveis ataques de XSS. Portanto, é essencial que os desenvolvedores tomem medidas adequadas para manter a segurança das aplicações web Java e prevenir vulnerabilidades de XSS ao criar páginas HTML.

Uma solução como a mostrada abaixo é uma maneira simples de implementar uma página renderizada no servidor sem um framework sofisticado, que normalmente vem com instruções específicas. No entanto, é claro que esse método tem algumas desvantagens.

Como gerar saída HTML no Spring MVC sem um framework de templates

Imagine que você tenha uma aplicação web que recebe o nome de um produto e o exibe em uma página usando o objeto HttpServletResponse. Veja um exemplo de como implementar esse recurso em um controller do Spring MVC:

1@GetMapping("/direct")
2public void directLink (@RequestParam String param, HttpServletResponse response) throws IOException {
3   Product prod = productService.getProductByName(param);
4
5   response.setContentType("text/html");
6   var writer = response.getWriter();
7   writer.write(head);
8   writer.write("<div class=\"panel-heading\"><h1>"+ param + "</h1></div>");
9
10   String output = "<div class=\"panel-body\">" +
11           "<ul>" +
12           "<li>%s</li>" +
13           "<li>%s</li>" +
14           "<li>%s</li>" +
15           "</ul>" +
16           "</div>";
17
18   writer.write(String.format(output, prod.getDescription(), prod.getProductType(), prod.getPrice()));
19   writer.write(foot);
20
21   response.getWriter().flush();
22}

Você consegue identificar que tipos de vulnerabilidade de segurança podem ser introduzidos pelo código Java acima?

Como encontrar XSS com Snyk Code

Ao analisar atentamente a função acima, talvez você já reconheça pelo menos uma vulnerabilidade de XSS — e possivelmente até duas. Ao analisar minha aplicação com Snyk Code, recebemos alertas sobre dois problemas diferentes de XSS nesse método.

Há várias maneiras de aproveitar o Snyk Code. Vamos ver três exemplos diferentes. A forma mais direta de um desenvolvedor receber feedback do Snyk Code é instalar um plugin no IDE. Temos plugins disponíveis para vários IDEs. No exemplo a seguir, mostro como o plugin do IntelliJ me ajuda a encontrar problemas de XSS durante o desenvolvimento.

Resultado do plugin do IntelliJ:

Outra opção é executar o Snyk Code pela Snyk CLI. Ao executar o comando snyk code test no terminal, você verá um resultado como o abaixo. Esse método é útil na sua máquina local ou como parte da compilação automatizada em um pipeline de CI/CD.

Resultado da CLI:

A terceira opção que quero mostrar é a interface web. Para obter esse resultado, usei a integração com Git e conectei meu repositório do GitHub à interface web do Snyk pelo dashboard em https://app.snyk.io. Essa solução analisa o código enviado ao meu repositório em busca de vulnerabilidades de segurança.

Resultado da interface web:

As três opções de análise mostram que há dois problemas distintos de segurança relacionados a XSS que preciso corrigir — e o Snyk Code identifica exatamente onde eles estão no meu código. Vamos analisar cada um e ver como podemos mitigá-los.

XSS refletido

XSS refletido é um tipo de ataque de XSS que ocorre quando alguém injeta código malicioso em uma aplicação web, e esse código é devolvido ao usuário como parte da resposta. No exemplo que mostrei, se a entrada do usuário não fosse validada ou sanitizada corretamente antes de ser gravada na resposta, uma pessoa mal-intencionada poderia injetar um script que seria executado por outros usuários ao acessarem a página. Esse tipo de ataque de XSS costuma ser usado para roubar dados de usuários, modificar o conteúdo de sites ou realizar outras ações maliciosas.

O código acima recupera o nome do usuário a partir de um parâmetro da requisição HTTP e, em seguida, grava-o diretamente no objeto HttpServletResponse usando:

1writer.write("<div class=\"panel-heading\"><h1>"+ param + "</h1></div>")

Esse código é vulnerável a ataques de XSS porque não valida nem sanitiza corretamente a entrada do usuário. Por exemplo, uma pessoa mal-intencionada poderia injetar código HTML ou JavaScript no parâmetro "name", que seria executado por outros usuários ao acessarem a página.

Por exemplo: .../direct?param=<script>alert(document.cookie);</script> pode revelar informações dos seus cookies pessoais. Isso significa que também podemos enviar essas informações para outro servidor sem que você saiba.

O Snyk Code detectou esse problema e apontou a vulnerabilidade de XSS na linha 93.

XSS armazenado

Já o XSS armazenado é um tipo de ataque em que o código malicioso fica armazenado no servidor e é enviado a todos os usuários que acessam a página afetada. No exemplo que mostrei, se a entrada do usuário não fosse validada ou sanitizada corretamente e fosse armazenada em um banco de dados, uma pessoa mal-intencionada poderia injetar um script que seria enviado a todos os usuários que acessassem a página afetada. Esse tipo de ataque pode ser especialmente perigoso, pois afeta muitos usuários e pode persistir mesmo depois que a injeção inicial é corrigida.

O código acima recupera um produto do ProductService e, em seguida, exibe seus campos como parte da string de saída. No entanto, esse código é vulnerável a ataques de XSS armazenado porque não valida nem sanitiza corretamente os dados recebidos do banco de dados. A sanitização é particularmente importante quando você não tem certeza de quem tem permissão para gravar no banco. Por exemplo, uma pessoa mal-intencionada poderia enviar uma descrição de produto contendo código HTML ou JavaScript, que seria armazenada no banco de dados e exibida a todos os usuários que visitassem a página do produto.

O Snyk Code apontou esse possível problema de XSS na linha 103, onde inserimos product.description na string de saída sem validá-lo nem sanitizá-lo.

Como mitigar vulnerabilidades de XSS com Snyk Code

Para prevenir vulnerabilidades de XSS, é importante validar e sanitizar corretamente as entradas do usuário antes de gravá-las na resposta. O Snyk Code já ajuda ao apontar possíveis soluções. Uma opção é usar uma biblioteca como Apache Commons Text para codificar a entrada e impedir a execução de código malicioso.

Com a função escapeHtml4(), podemos garantir que o código em casos de XSS refletido e armazenado seja escapado e não seja executado quando a página for carregada.

É claro que outras bibliotecas também podem fazer esse tipo de escape. Além de Apache Commons Text, você pode consultar o OWASP Encoder. Se você trabalha com Spring, também pode usar o HtmlUtils.htmlEscape do Spring.

Com o Apache Commons Text, o código devidamente escapado poderia ficar assim:

1@GetMapping("/direct")
2public void directLink (@RequestParam String param, HttpServletResponse response) throws IOException {
3   Product prod = productService.getProductByName(param);
4
5   response.setContentType("text/html");
6   var writer = response.getWriter();
7   writer.write(head);
8   writer.write("<div class=\"panel-heading\"><h1>"+ StringEscapeUtils.escapeHtml4(param) + "</h1></div>");
9
10   String output = "<div class=\"panel-body\">" +
11           "<ul>" +
12           "<li>%s</li>" +
13           "<li>%s</li>" +
14           "<li>%s</li>" +
15           "</ul>" +
16           "</div>";
17
18   writer.write(String.format(output,
19             StringEscapeUtils.escapeHtml4(prod.getDescription()),
20             StringEscapeUtils.escapeHtml4(prod.getProductType()),
21             StringEscapeUtils.escapeHtml4(prod.getPrice())));
22
23   writer.write(foot);

Tenha cuidado com frameworks de templates

Frameworks de templates como o Thymeleaf podem ajudar a proteger contra vulnerabilidades de XSS. O Thymeleaf é um mecanismo de templates popular para Java, com suporte integrado para escape de HTML. Isso ajuda a prevenir ataques de XSS ao codificar todas as entradas do usuário incluídas no HTML renderizado.

No entanto, isso depende muito de como você cria o template. Por exemplo, veja como usar o Thymeleaf para renderizar um produto parecido com o do exemplo anterior:

1<div class="product" th:each="product : ${products}">
2  <p th:text="${product.name}"></p>
3  <p th:text="${product.type}"></p>
4  <p th:text="${product.pric}"></p>
5  <p th:utext="${product.descriptiont}"></p>
6</div>

Neste exemplo, os atributos th:text escapam o conteúdo, mas o atributo th:utext não. O atributo th:utext renderiza o texto do comentário sem escapar tags HTML nem caracteres especiais e, por isso, pode estar vulnerável a XSS. Ao usar um framework, é essencial saber como determinados elementos se comportam.

Detecte XSS antes de publicar em produção

Prevenir ataques de XSS é uma preocupação fundamental para quem desenvolve aplicações web Java. É essencial identificar e corrigir vulnerabilidades de XSS o quanto antes no processo de desenvolvimento. Embora a sanitização das entradas do usuário possa mitigar ataques de XSS de forma eficaz, nem sempre ela é suficiente.

Consulte recursos como o OWASP XSS Cheat Sheet e a lição do Snyk Learn sobre XSS para se manter atualizado sobre as ameaças mais recentes e as práticas recomendadas para prevenir XSS.

Além disso, é importante usar as ferramentas certas para detectar problemas de XSS e outras questões de segurança antes que cheguem à produção. O Snyk Code é uma ferramenta gratuita valiosa para identificar possíveis vulnerabilidades de segurança logo no início do ciclo de desenvolvimento. Com uma abordagem proativa para prevenir XSS e os recursos e as ferramentas adequados, os desenvolvedores podem ajudar a garantir a segurança e a integridade de suas aplicações web Java.