S03L05 - Controlador de Autenticação Spring Boot, Listar Usuários Adicionar Segurança

html

Protegendo APIs Spring Boot com Spring Security e Autenticação JWT
Índice

Introdução ................................................................. 1
Compreendendo o Spring Security ................. 3
Autenticação Baseada em Token com JWT ..... 7
Implementando Configurações de Segurança ..... 12
Criando o Auth Controller ................... 18
Gerenciando Funções e Autoridades de Usuários ... 25
Tratando Exceções de Segurança .................... 30
Testando a API Protegida ............................ 35
Conclusão ......................................................................... 42


Introdução
No cenário moderno de desenvolvimento web, proteger APIs é fundamental. À medida que as aplicações crescem em complexidade e manipulam dados sensíveis, garantir mecanismos robustos de autenticação e autorização torna-se essencial. Este eBook aprofunda-se na proteção de APIs Spring Boot usando Spring Security combinado com JSON Web Tokens (JWT) para autenticação baseada em token. Exploraremos as complexidades do Spring Security, implementaremos autenticação baseada em JWT, gerenciaremos funções de usuários, trataremos exceções de segurança e testaremos nossa API protegida para garantir uma proteção inabalável.
Importância de Proteger APIs
APIs frequentemente servem como a espinha dorsal de aplicações modernas, facilitando a comunicação entre diferentes serviços e clientes. Sem medidas de segurança adequadas, as APIs são vulneráveis a várias ameaças, incluindo acesso não autorizado, violações de dados e uso indevido de recursos. Implementar segurança robusta garante que apenas usuários autenticados e autorizados possam interagir com sua API, protegendo tanto seus dados quanto seus usuários.
Propósito deste eBook
Este eBook tem como objetivo fornecer um guia abrangente para iniciantes e desenvolvedores com conhecimento básico para proteger efetivamente APIs Spring Boot. Através de explicações detalhadas, trechos de código e exemplos práticos, você adquirirá as habilidades necessárias para implementar e gerenciar a segurança em suas aplicações com confiança.
Visão Geral da Tabela


Tópico
Descrição


Spring Security
Visão geral e configuração do Spring Security em projetos Spring Boot


Autenticação JWT
Compreendendo e implementando autenticação baseada em token


Configurações de Segurança
Configurando definições de segurança para APIs


Auth Controller
Criando controllers para tratar processos de autenticação


Funções e Autoridades de Usuários
Gerenciando funções e permissões de usuários


Exceções de Segurança
Tratando e personalizando exceções de segurança


Testando APIs Protegidas
Garantindo que as medidas de segurança estão funcionando conforme o esperado


Quando e Onde Usar Autenticação JWT
A autenticação baseada em JWT é ideal para aplicações sem estado, microserviços e cenários onde a escalabilidade é essencial. Ela permite a transmissão segura de informações entre partes e é amplamente adotada devido à sua simplicidade e eficácia no tratamento de autenticação e autorização.

Compreendendo o Spring Security
O Spring Security é um framework poderoso e altamente personalizável projetado para lidar com autenticação e autorização em aplicações Java. Ele se integra perfeitamente com o Spring Boot, fornecendo recursos de segurança abrangentes prontos para uso.
Principais Características do Spring Security

Autenticação e Autorização: Lida com processos de login de usuários e controle de acesso a recursos.
Suporte Abrangente: Suporta vários mecanismos de autenticação, incluindo baseado em formulário, OAuth2 e LDAP.
Extensibilidade: Fácil personalização para atender necessidades específicas de segurança.
Proteção Contra Ameaças Comuns: Protege contra ataques como CSRF, fixação de sessão e mais.

Configurando o Spring Security no Spring Boot
Para integrar o Spring Security em seu projeto Spring Boot, siga estes passos:

Adicionar Dependência: Inclua a dependência do Spring Security em seu pom.xml.





		
		
			
			
Java
			
			&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;

			
				
					
				
					1
2
3
4
5
				
						&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
 
					
				
			
		



Configurar Definições de Segurança: Crie uma classe de configuração de segurança para definir comportamentos de segurança.





		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .anyRequest().authenticated();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .anyRequest().authenticated();
    }
}
 
					
				
			
		



Definir User Details Service: Implemente um serviço para carregar dados específicos do usuário.





		
		
			
			
Java
			
			@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("Usuário não encontrado");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), new ArrayList&lt;&gt;());
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("Usuário não encontrado");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), new ArrayList&lt;&gt;());
    }
}
 
					
				
			
		


Benefícios de Usar o Spring Security

Segurança Abrangente: Oferece uma ampla gama de recursos de segurança prontos para uso.
Facilidade de Integração: Integra-se perfeitamente com aplicações Spring Boot.
Personalizável: Altamente adaptável para atender necessidades específicas de segurança.
Comunidade Ativa e Suporte: Bem documentado com forte apoio da comunidade.


Autenticação Baseada em Token com JWT
JSON Web Tokens (JWT) fornecem um método sem estado e escalável para lidar com autenticação e autorização. Ao contrário da autenticação tradicional baseada em sessão, JWT elimina a necessidade de sessões no servidor, melhorando o desempenho e a escalabilidade.
O que é JWT?
JWT é um meio compacto e seguro por URL de representar reivindicações a serem transferidas entre duas partes. O token consiste em três partes:

Header: Especifica o tipo de token e o algoritmo de hash.
Payload: Contém as reivindicações ou dados.
Signature: Garante a integridade do token.

Como o JWT Funciona na Autenticação

Login do Usuário: O usuário envia credenciais para o servidor.
Geração de Token: Após autenticação bem-sucedida, o servidor gera um JWT e o envia para o usuário.
Armazenamento do Token: O cliente armazena o JWT (comumente no localStorage ou cookies).
Requisições Autenticadas: O cliente inclui o JWT no cabeçalho Authorization para requisições subsequentes.
Verificação do Token: O servidor verifica a validade do JWT e concede ou nega acesso com base nas reivindicações do token.

Vantagens de Usar JWT

Sem Estado: Não há necessidade de armazenar informações de sessão no servidor.
Escalável: Adequado para sistemas distribuídos e microserviços.
Seguro: Pode ser assinado e criptografado para garantir a integridade e confidencialidade dos dados.
Flexível: Suporta várias estruturas de payload para se adequar a diferentes casos de uso.

Implementando JWT no Spring Boot
Para implementar autenticação baseada em JWT no Spring Boot:

Gerar JWT: Crie tokens após autenticação bem-sucedida.





		
		
			
			
Java
			
			public class JwtUtil {
    private String secret = "mysecretkey";

    public String generateToken(UserDetails userDetails) {
        Map&lt;String, Object&gt; claims = new HashMap&lt;&gt;();
        return createToken(claims, userDetails.getUsername());
    }

    private String createToken(Map&lt;String, Object&gt; claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						public class JwtUtil {
    private String secret = "mysecretkey";
 
    public String generateToken(UserDetails userDetails) {
        Map&lt;String, Object&gt; claims = new HashMap&lt;&gt;();
        return createToken(claims, userDetails.getUsername());
    }
 
    private String createToken(Map&lt;String, Object&gt; claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
}
 
					
				
			
		



Validar JWT: Verifique a integridade e expiração do token.





		
		
			
			
Java
			
			public boolean validateToken(String token, UserDetails userDetails) {
    final String username = extractUsername(token);
    return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}

			
				
					
				
					1
2
3
4
5
				
						public boolean validateToken(String token, UserDetails userDetails) {
    final String username = extractUsername(token);
    return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}
 
					
				
			
		



Usar JWT em Requisições: Inclua o token no cabeçalho Authorization.





		
		
			
			
Java
			
			Authorization: Bearer &lt;token&gt;

			
				
					
				
					1
2
				
						Authorization: Bearer &lt;token&gt;
 
					
				
			
		



Implementando Configurações de Segurança
Configurar o Spring Security é crucial para definir como sua aplicação lida com preocupações de segurança. Esta seção descreve a configuração de definições de segurança para permitir autenticação baseada em JWT.
Criando a Classe de Configuração de Segurança
A classe de configuração de segurança estende WebSecurityConfigurerAdapter para personalizar o comportamento de segurança.




		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Autowired
    private MyUserDetailsService myUserDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .antMatchers("/users/**").hasAuthority("USER")
            .anyRequest().authenticated()
            .and().sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private JwtRequestFilter jwtRequestFilter;
 
    @Autowired
    private MyUserDetailsService myUserDetailsService;
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService);
    }
 
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .antMatchers("/users/**").hasAuthority("USER")
            .anyRequest().authenticated()
            .and().sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}
 
					
				
			
		


Definindo o JWT Request Filter
O JWT request filter intercepta requisições entrantes para validar o JWT.




		
		
			
			
Java
			
			@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private MyUserDetailsService myUserDetailsService;

    @Autowired
    private JwtUtil jwtUtil;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
 
        final String authorizationHeader = request.getHeader("Authorization");
 
        String username = null;
        String jwt = null;
 
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
 
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
 
            UserDetails userDetails = this.myUserDetailsService.loadUserByUsername(username);
 
            if (jwtUtil.validateToken(jwt, userDetails)) {
 
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
				
						@Component
public class JwtRequestFilter extends OncePerRequestFilter {
 
    @Autowired
    private MyUserDetailsService myUserDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
 
        final String authorizationHeader = request.getHeader("Authorization");
 
        String username = null;
        String jwt = null;
 
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
 
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
 
            UserDetails userDetails = this.myUserDetailsService.loadUserByUsername(username);
 
            if (jwtUtil.validateToken(jwt, userDetails)) {
 
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}
 
					
				
			
		


Configurando a Gestão de Sessão
Definir a política de criação de sessão como sem estado garante que o servidor não armazena nenhuma informação de sessão, alinhando-se com a natureza sem estado do JWT.




		
		
			
			
Java
			
			.and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS);

			
				
					
				
					1
2
3
				
						.and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS);
 
					
				
			
		


Resumo das Configurações de Segurança

Desativar CSRF: Como o JWT é imune a ataques CSRF, é comum desativar a proteção CSRF para APIs.
Permitir Todos para Endpoints de Autenticação: Permite acesso aberto a endpoints de autenticação como /auth/login e /auth/signup.
Autorizar Requisições com Base em Funções/Autoridades: Restringe o acesso a endpoints específicos com base em funções ou autoridades de usuários.
Adicionar o Filtro JWT: Integra o JWT request filter para validar tokens em requisições entrantes.
Definir Política de Sessão como Sem Estado: Garante que nenhum dado de sessão seja armazenado no servidor, mantendo a natureza sem estado do JWT.


Criando o Auth Controller
O Auth Controller trata os processos de autenticação de usuários, incluindo login e geração de token. Ele serve como ponto de entrada para os usuários obterem JWTs após autenticação bem-sucedida.
Implementando o AuthController




		
		
			
			
Java
			
			@RestController
@RequestMapping("/auth")
public class AuthController {

    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private MyUserDetailsService userDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity&lt;?&gt; createAuthenticationToken(@RequestBody UserLoginDTO authenticationRequest) throws Exception {
        try {
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(authenticationRequest.getUsername(), authenticationRequest.getPassword())
            );
        }
        catch (BadCredentialsException e) {
            throw new Exception("Nome de usuário ou senha incorretos", e);
        }
 
        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());
 
        final String jwt = jwtUtil.generateToken(userDetails);
 
        return ResponseEntity.ok(new TokenDTO(jwt));
    }

    @PostMapping("/signup")
    public ResponseEntity&lt;?&gt; signup(@RequestBody AccountDTO accountDTO) {
        // Lógica para criar um novo usuário
        return ResponseEntity.ok("Usuário registrado com sucesso");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
				
						@RestController
@RequestMapping("/auth")
public class AuthController {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private MyUserDetailsService userDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @PostMapping("/login")
    public ResponseEntity&lt;?&gt; createAuthenticationToken(@RequestBody UserLoginDTO authenticationRequest) throws Exception {
        try {
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(authenticationRequest.getUsername(), authenticationRequest.getPassword())
            );
        }
        catch (BadCredentialsException e) {
            throw new Exception("Nome de usuário ou senha incorretos", e);
        }
 
        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());
 
        final String jwt = jwtUtil.generateToken(userDetails);
 
        return ResponseEntity.ok(new TokenDTO(jwt));
    }
 
    @PostMapping("/signup")
    public ResponseEntity&lt;?&gt; signup(@RequestBody AccountDTO accountDTO) {
        // Lógica para criar um novo usuário
        return ResponseEntity.ok("Usuário registrado com sucesso");
    }
}
 
					
				
			
		


Explicação do AuthController

Endpoint de Login (/auth/login):

  - Autenticação: Valida as credenciais do usuário usando o AuthenticationManager.

  - Geração de JWT: Após autenticação bem-sucedida, gera um JWT usando a classe JwtUtil.

  - Resposta: Retorna o JWT encapsulado em um objeto TokenDTO.
Endpoint de Signup (/auth/signup):

  - Registro de Usuário: Trata a lógica para registrar um novo usuário.

  - Resposta: Confirma o registro bem-sucedido.

Classes DTO
UserLoginDTO




		
		
			
			
Java
			
			public class UserLoginDTO {
    private String username;
    private String password;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
				
						public class UserLoginDTO {
    private String username;
    private String password;
 
    // Getters and Setters
}
 
					
				
			
		


TokenDTO




		
		
			
			
Java
			
			public class TokenDTO {
    private String token;

    public TokenDTO(String token) {
        this.token = token;
    }

    // Getter
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class TokenDTO {
    private String token;
 
    public TokenDTO(String token) {
        this.token = token;
    }
 
    // Getter
}
 
					
				
			
		


AccountDTO




		
		
			
			
Java
			
			public class AccountDTO {
    private String username;
    private String password;
    private String role;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class AccountDTO {
    private String username;
    private String password;
    private String role;
 
    // Getters and Setters
}
 
					
				
			
		


Tratando Exceções de Autenticação
Personalizar as exceções de autenticação melhora a clareza das mensagens de erro e aprimora a experiência do usuário.




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(BadCredentialsException.class)
    public ResponseEntity&lt;?&gt; handleBadCredentialsException(BadCredentialsException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Nome de usuário ou senha inválidos");
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Ocorreu um erro");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@ControllerAdvice
public class CustomExceptionHandler {
 
    @ExceptionHandler(BadCredentialsException.class)
    public ResponseEntity&lt;?&gt; handleBadCredentialsException(BadCredentialsException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Nome de usuário ou senha inválidos");
    }
 
    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Ocorreu um erro");
    }
}
 
					
				
			
		



Gerenciando Funções e Autoridades de Usuários
O gerenciamento eficaz de funções e autoridades de usuários garante que os usuários tenham níveis de acesso apropriados dentro da aplicação. O Spring Security distingue entre funções e autoridades, fornecendo controle granular sobre o acesso a recursos.
Compreendendo Funções vs. Autoridades

Funções: Categorias amplas de usuários (por exemplo, USER, ADMIN). Tipicamente prefixadas com ROLE_.
Autoridades: Permissões específicas atribuídas a usuários (por exemplo, READ_PRIVILEGES, WRITE_PRIVILEGES).

Configurando Funções e Autoridades no Spring Security




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


Atribuindo Funções aos Usuários
Ao criar ou atualizar contas de usuários, atribua as funções apropriadas.




		
		
			
			
Java
			
			public Account createNewUser(AccountDTO accountDTO) {
    Account account = new Account();
    account.setUsername(accountDTO.getUsername());
    account.setPassword(passwordEncoder.encode(accountDTO.getPassword()));
    account.setRoles(Arrays.asList(new Role(accountDTO.getRole())));
    return accountRepository.save(account);
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						public Account createNewUser(AccountDTO accountDTO) {
    Account account = new Account();
    account.setUsername(accountDTO.getUsername());
    account.setPassword(passwordEncoder.encode(accountDTO.getPassword()));
    account.setRoles(Arrays.asList(new Role(accountDTO.getRole())));
    return accountRepository.save(account);
}
 
					
				
			
		


Configuração de Seed Data
Seed data inicializa o banco de dados com usuários e funções pré-definidos.




		
		
			
			
Java
			
			@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void run(String... args) throws Exception {
        Account admin = new Account();
        admin.setUsername("admin");
        admin.setPassword(passwordEncoder.encode("admin123"));
        admin.setRoles(Arrays.asList(new Role("ADMIN")));

        Account user = new Account();
        user.setUsername("user");
        user.setPassword(passwordEncoder.encode("user123"));
        user.setRoles(Arrays.asList(new Role("USER")));

        accountRepository.save(admin);
        accountRepository.save(user);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AccountRepository accountRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    @Override
    public void run(String... args) throws Exception {
        Account admin = new Account();
        admin.setUsername("admin");
        admin.setPassword(passwordEncoder.encode("admin123"));
        admin.setRoles(Arrays.asList(new Role("ADMIN")));
 
        Account user = new Account();
        user.setUsername("user");
        user.setPassword(passwordEncoder.encode("user123"));
        user.setRoles(Arrays.asList(new Role("USER")));
 
        accountRepository.save(admin);
        accountRepository.save(user);
    }
}
 
					
				
			
		


Tratando Múltiplas Autoridades
Usuários podem possuir múltiplas autoridades, proporcionando controle de acesso flexível.




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/reports/**").hasAnyAuthority("USER", "ADMIN")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/reports/**").hasAnyAuthority("USER", "ADMIN")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


Resumo

Funções e Autoridades: Use funções para acesso amplo e autoridades para permissões específicas.
Atribuição: Atribua funções e autoridades durante a criação ou atualização de usuários.
Configuração: Defina regras de acesso na configuração de segurança com base em funções e autoridades.
Flexibilidade: Implemente múltiplas autoridades para atender a requisitos complexos de controle de acesso.


Tratando Exceções de Segurança
Tratar corretamente as exceções de segurança aumenta a robustez de sua aplicação, proporcionando feedback claro aos usuários e mantendo a integridade da aplicação.
Exceções Comuns de Segurança

401 Unauthorized: Indica que a requisição carece de credenciais de autenticação válidas.
403 Forbidden: Indica que o servidor entende a requisição, mas se recusa a autorizá-la.

Personalizando Respostas de Exceções




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(UnauthorizedException.class)
    public ResponseEntity&lt;?&gt; handleUnauthorizedException(UnauthorizedException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Por favor, verifique seu token de acesso");
    }

    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Escopo ou permissões insuficientes");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@ControllerAdvice
public class CustomExceptionHandler {
 
    @ExceptionHandler(UnauthorizedException.class)
    public ResponseEntity&lt;?&gt; handleUnauthorizedException(UnauthorizedException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Por favor, verifique seu token de acesso");
    }
 
    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Escopo ou permissões insuficientes");
    }
}
 
					
				
			
		


Atualizando Configurações de Segurança para Tratar Exceções




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and()
        .exceptionHandling()
        .authenticationEntryPoint((request, response, authException) -> {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Por favor, verifique seu token de acesso");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Escopo ou permissões insuficientes");
        })
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and()
        .exceptionHandling()
        .authenticationEntryPoint((request, response, authException) -> {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Por favor, verifique seu token de acesso");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Escopo ou permissões insuficientes");
        })
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


Melhorando a Documentação Swagger com Respostas de Segurança
Ao documentar APIs usando Swagger, inclua respostas relacionadas à segurança para informar os usuários sobre possíveis estados de erro.




		
		
			
			
Java
			
			@Operation(summary = "Listar todos os usuários", responses = {
    @ApiResponse(responseCode = "200", description = "Lista recuperada com sucesso"),
    @ApiResponse(responseCode = "401", description = "Unauthorized - Por favor, verifique seu token de acesso"),
    @ApiResponse(responseCode = "403", description = "Forbidden - Escopo ou permissões insuficientes")
})
@GetMapping("/users")
public List&lt;User&gt; getAllUsers() {
    return userService.getAllUsers();
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						@Operation(summary = "Listar todos os usuários", responses = {
    @ApiResponse(responseCode = "200", description = "Lista recuperada com sucesso"),
    @ApiResponse(responseCode = "401", description = "Unauthorized - Por favor, verifique seu token de acesso"),
    @ApiResponse(responseCode = "403", description = "Forbidden - Escopo ou permissões insuficientes")
})
@GetMapping("/users")
public List&lt;User&gt; getAllUsers() {
    return userService.getAllUsers();
}
 
					
				
			
		


Resumo do Tratamento de Exceções

Mensagens Claras: Forneça mensagens de erro amigáveis para diferentes tipos de exceção.
Tratamento Centralizado: Use @ControllerAdvice para gerenciar exceções globalmente.
Integração com Swagger: Documente possíveis exceções de segurança na documentação da API.
Manter a Segurança: Evite expor informações sensíveis através das mensagens de erro.


Testando a API Protegida
Garantir que suas configurações de segurança funcionem conforme o esperado é crucial. Esta seção cobre estratégias de teste para validar mecanismos de autenticação e autorização.
Testando o Fluxo de Autenticação

Tentar Acesso Não Autorizado:

  - Ação: Acesse um endpoint protegido sem um token.

  - Resultado Esperado: Receber uma resposta 401 Unauthorized.
Login com Credenciais Válidas:

  - Ação: Envie uma requisição POST para /auth/login com credenciais válidas.

  - Resultado Esperado: Receber um JWT na resposta.
Login com Credenciais Inválidas:

  - Ação: Envie uma requisição POST para /auth/login com credenciais inválidas.

  - Resultado Esperado: Receber uma resposta 401 Unauthorized com uma mensagem de erro.

Testando o Fluxo de Autorização

Acessar com Token Válido:

  - Ação: Use o JWT recebido para acessar um endpoint protegido.

  - Resultado Esperado: Acesso bem-sucedido com dados apropriados.
Acessar com Token Inválido:

  - Ação: Use um JWT inválido ou adulterado.

  - Resultado Esperado: Receber uma resposta 401 Unauthorized.
Acessar com Permissões Insuficientes:

  - Ação: Use um JWT sem as autoridades necessárias para acessar um endpoint restrito.

  - Resultado Esperado: Receber uma resposta 403 Forbidden.

Usando Swagger para Testar
O Swagger UI é uma excelente ferramenta para testar suas APIs interativamente.

Gerar Token:

  - Navegue para o endpoint /auth/login.

  - Forneça credenciais válidas para receber um JWT.
Autorizar no Swagger:

  - Clique no botão "Authorize" no Swagger.

  - Insira o JWT como Bearer <token>.
Acessar Endpoints Protegidos:

  - Tente acessar endpoints como /users ou /admin.

  - Observe as respostas com base na validade e permissões do token.

Testes Automatizados com Postman
O Postman pode automatizar e agilizar os testes de API.

Configurar Coleções:

  - Crie requisições para login, acessar endpoints protegidos, etc.
Usar Variáveis de Ambiente:

  - Armazene e reutilize tokens em várias requisições.
Assertar Respostas:

  - Defina respostas esperadas para diferentes cenários.

Exemplos de Código para Testes
Testando Acesso Não Autorizado




		
		
			
			
Java
			
			curl -X GET http://localhost:8080/users

			
				
					
				
					1
2
				
						curl -X GET http://localhost:8080/users
 
					
				
			
		


Resposta Esperada:




		
		
			
			
Java
			
			401 Unauthorized - Por favor, verifique seu token de acesso

			
				
					
				
					1
2
				
						401 Unauthorized - Por favor, verifique seu token de acesso
 
					
				
			
		


Testando Acesso Autorizado




		
		
			
			
Java
			
			curl -X GET http://localhost:8080/users -H "Authorization: Bearer &lt;valid_token&gt;"

			
				
					
				
					1
2
				
						curl -X GET http://localhost:8080/users -H "Authorization: Bearer &lt;valid_token&gt;"
 
					
				
			
		


Resposta Esperada:




		
		
			
			
Java
			
			[
    {
        "id": 1,
        "username": "user1",
        "email": "user1@example.com"
    },
    {
        "id": 2,
        "username": "admin",
        "email": "admin@example.com"
    }
]

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						[
    {
        "id": 1,
        "username": "user1",
        "email": "[email protected]"
    },
    {
        "id": 2,
        "username": "admin",
        "email": "[email protected]"
    }
]
 
					
				
			
		


Resumo

Testes Abrangentes: Valide tanto fluxos de autenticação quanto de autorização.
Usar Ferramentas Eficientemente: Aproveite o Swagger e o Postman para facilitar os testes.
Automatizar Quando Possível: Implemente testes automatizados para garantir verificações de segurança consistentes.
Monitorar Respostas: Assegure-se de que as respostas estejam alinhadas com os comportamentos de segurança esperados.


Conclusão
Proteger APIs é um aspecto fundamental do desenvolvimento de aplicações modernas, salvaguardando dados sensíveis e garantindo que apenas usuários autorizados possam acessar recursos protegidos. Ao integrar o Spring Security com autenticação baseada em token JWT, os desenvolvedores podem implementar mecanismos de segurança robustos, escaláveis e eficientes em suas aplicações Spring Boot.
Ao longo deste eBook, exploramos os conceitos fundamentais do Spring Security, a mecânica da autenticação JWT, as complexidades da configuração das definições de segurança, o gerenciamento de funções e autoridades de usuários, o tratamento de exceções de segurança e a efetiva testagem de APIs protegidas. Cada componente desempenha um papel vital na construção de um ecossistema de API seguro.
Principais Conclusões

Integração do Spring Security: Integra-se perfeitamente com o Spring Boot para fornecer recursos de segurança abrangentes.
Autenticação JWT: Oferece um método sem estado e escalável para lidar com autenticação e autorização de usuários.
Gerenciamento de Funções e Autoridades: Permite controle granular sobre permissões de usuários e níveis de acesso.
Tratamento de Exceções: Assegura que erros relacionados à segurança sejam gerenciados de forma graciosa e informativa.
Testes Rigorosos: Valida a eficácia das implementações de segurança, prevenindo possíveis vulnerabilidades.

À medida que as aplicações continuam a evoluir, manter e aprimorar as medidas de segurança permanece um esforço contínuo. Manter-se informado sobre as melhores práticas, ameaças emergentes e soluções inovadoras é essencial para desenvolvedores comprometidos com a construção de aplicações seguras e confiáveis.
Chamada para Ação
Fortaleça seu fluxo de desenvolvimento implementando as estratégias de segurança delineadas neste eBook. Comece integrando o Spring Security e o JWT em seus projetos Spring Boot e refine continuamente sua postura de segurança para se adaptar aos desafios em constante evolução. Para um aprendizado adicional, explore tópicos avançados como integração OAuth2, autenticação multifator e auditoria de segurança para aprofundar sua expertise em segurança de APIs.

Nota: Este artigo foi gerado por IA.
Tópico	Descrição
Spring Security	Visão geral e configuração do Spring Security em projetos Spring Boot
Autenticação JWT	Compreendendo e implementando autenticação baseada em token
Configurações de Segurança	Configurando definições de segurança para APIs
Auth Controller	Criando controllers para tratar processos de autenticação
Funções e Autoridades de Usuários	Gerenciando funções e permissões de usuários
Exceções de Segurança	Tratando e personalizando exceções de segurança
Testando APIs Protegidas	Garantindo que as medidas de segurança estão funcionando conforme o esperado