Introdução

Provavelmente, se programa em Java, você já desenvolveu uma API REST usando Java com Spring, mas será que você configurou a segurança de quem pode acessar os seus dados? Ou um usuário comum pode acessar os dados sensíveis da sua aplicação?

Para se proteger disso, neste artigo, mostrarei a você em 4 passos como adicionar uma segurança básica a sua API usando o Spring Security.

Antes de por a mão no código:

O que é o Spring Security?

Spring Security é um módulo do Spring Framework que permite você proteger suas aplicação. Ele fornece a você estruturas de autenticação e autorização para proteger sua API REST. Neste artigo, iremos ver como implementar uma autenticação básica.

Terminologia:

Autenticação: É o processo de identificar quem está tentando acessar um recurso. Ex.: Pedir para o usuário realizar um login.

Autorização: Verifica se o usuário identificado pode ou não realizar uma determinada ação. Ex.: Com o usuário já identificado, verificar se ele pode acessar uma página específica.

Agora que você já tem essas definições, vamos começar a criar o nosso projeto.

1º Passo: Criação do Projeto

Para este artigo, iremos criar um projeto para exemplificar o uso do Spring Security. Recomendo usar o site Spring Initializr para facilitar a configuração inicial do projeto.

Abaixo estão as opções que devem ser selecionadas(Você também pode ver a imagem):

• Maven
• Spring Boot 3.3.0
• Java
• Jar
• Versão do Java 21
• Adicione a dependência do Spring Web

*** Não adicione ainda a dependência do Spring Security

2º Passo: Abra o projeto na sua IDE

Eu irei usar o IntelliJ IDEA, mas você pode escolher a de sua preferência.

3º Passo: Criar uma estrutura básica para poder visualizar o Spring Security em ação

3.1 Crie um novo pacote, chamado controller, na pasta raiz do projeto.

3.2 Crie uma classe (dentro desta pasta controller) chamada ExemploController

3.3 Use o seguinte código:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ExemploController {

  @GetMapping("/publico")
  public String rotaPublica() {
      return "<h1>Rota Pública</h1>" +
             "<h2>Você é livre para olhar esta página 👍<h2>" ;
  }

  @GetMapping("/privado")
  public String rotaPrivada() {
      return "<h1>Rota Privada</h1>" +
             "<p>Apenas pessoas autorizadas podem acessar esses dados! 🔒</p>" +
             "<p>Aqui estão algumas informações sensíveis:</p>" +
             "User: João da Silva<br>" +
             "Password: Senhasecreta123@<br>" +
             "CPF: 000.000.000-00<br>" +
             "Saldo Bancário: R$10.000.000,00<br>";
  }
} 

Este código cria um controlador REST(@RestController) e dois endpoints GET que retornam um HTML específico para cada, um simulando uma página pública e outro simulando uma página privada com dados sensíveis

3.4 Rode o projeto e acesse os endpoints

Você verá que é possível acessar as duas rotas sem nenhuma verificação.

/publico

/privado

4º Adicionar o Spring Security ao projeto

4.1 adicionar ao pom.xml a dependência do Spring Security

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Só de adicionar esta dependência ao projeto, o Spring Security já habilita a autenticação básica.

Rode o projeto novamente e tente acessar os endpoints. Você dará de cara com essa tela:

Basta logar na tela de login que você conseguirá visualizar o conteúdo dos endpoints.

O username padrão é "user" e a senha é gerada no console como msotra a imagem abaixo:

4.2 Criar um pacote , chamado config, na pasta raiz

4.3 Criar uma classe (dentro da pasta config) chamada SecurityConfig

4.4 Adicionar o código abaixo na classe SecurityConfig

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  SecurityFilterChain SecurityFilterChain(HttpSecurity http) throws Exception {
      return http
              .authorizeHttpRequests(
                      authorizeConfig -> {
                          authorizeConfig.requestMatchers("/publico").permitAll();
                          authorizeConfig.anyRequest().authenticated();
                      }
              )
              .formLogin(Customizer.withDefaults())
              .build();
  }
}

A anotação @EnableWebSecurity habilita a segurança web no projeto;

O método securityFilterChain() usa a classe HttpSecurity para configurar uma cadeia de filtros para definir as regras de segurança;

Dentro do bloco lambda:

authorizeConfig.requestMatchers("/publico").permitAll() : permite que todos os usuários possam acessar a rota (/publico) sem precisar se autentificar;

authorizeConfig.anyRequest().authenticated() : faz com que qualquer outra rota sem ser a '/publico' precise de autenticação;

formLogin(Customizer.withDefaults()) : ativa a autenticação baseada em formulário com uma configuração padrão.

Agora, ao tentar acessar o endpoint '/publico' você conseguirá acessar sem nenhum problema, mas ao tentar acessar o '/privado' será requerido que você realize um login de acesso. Lembrando que o username padrão é "user" e a senha é gerada no console da aplicação

Pronto

Conseguimos implementar uma autenticação básica com o Spring Security. Você aprendeu a adicionar o Spring Security ao projeto e configurar regras de segurança básicas que permitem acessos à algumas rotas e proíbem outras.

Agora, com esta base de conhecimento você pode procurar estudar mais sobre:

• JWT (JSON Web Token)
• OAuth2
• Autenticação baseada em tokens
• Autenticação de dois fatores(2FA)

Referências

Documentação do Spring Security: https://docs.spring.io/spring-security/reference/index.html

Curso da DIO: Adicionando Segurança a uma API REST Com Spring Security

Vídeo: Aulão: Proteja o acesso aos seus serviços web com o Spring Security 6!