S03L05 - Controlador de Autenticación de Spring Boot, Listar Usuarios, Añadir Seguridad

html

Asegurando APIs de Spring Boot con Spring Security y Autenticación JWT
Tabla de Contenidos

Introducción ................................................................. 1
Comprendiendo Spring Security ................. 3
Autenticación Basada en Token con JWT ..... 7
Implementando Configuraciones de Seguridad ..... 12
Creando el Auth Controller ................... 18
Administrando Roles y Autoridades de Usuarios ... 25
Manejo de Excepciones de Seguridad .................... 30
Probando la API Asegurada ............................ 35
Conclusión ......................................................................... 42


Introducción
En el panorama moderno del desarrollo web, asegurar las APIs es primordial. A medida que las aplicaciones crecen en complejidad y manejan datos sensibles, asegurar mecanismos robustos de autenticación y autorización se vuelve esencial. Este eBook profundiza en la seguridad de APIs de Spring Boot utilizando Spring Security combinado con JSON Web Tokens (JWT) para autenticación basada en tokens. Exploraremos las complejidades de Spring Security, implementaremos autenticación basada en JWT, administraremos roles de usuario, manejaremos excepciones de seguridad y probaremos nuestra API asegurada para garantizar una protección inquebrantable.
Importancia de Asegurar APIs
Las APIs a menudo sirven como la columna vertebral de las aplicaciones modernas, facilitando la comunicación entre diferentes servicios y clientes. Sin medidas de seguridad adecuadas, las APIs son vulnerables a varias amenazas, incluyendo acceso no autorizado, violaciones de datos y mal uso de recursos. Implementar una seguridad robusta garantiza que solo usuarios autenticados y autorizados puedan interactuar con tu API, protegiendo tanto tus datos como a tus usuarios.
Propósito de Este eBook
Este eBook tiene como objetivo proporcionar una guía completa para principiantes y desarrolladores con conocimientos básicos para asegurar eficazmente las APIs de Spring Boot. A través de explicaciones detalladas, fragmentos de código y ejemplos prácticos, adquirirás las habilidades necesarias para implementar y gestionar la seguridad en tus aplicaciones con confianza.
Descripción de la Tabla


Tema
Descripción


Spring Security
Visión general y configuración de Spring Security en proyectos de Spring Boot


Autenticación JWT
Comprensión e implementación de autenticación basada en tokens


Configuraciones de Seguridad
Configuración de ajustes de seguridad para APIs


Auth Controller
Creación de controladores para manejar procesos de autenticación


Roles y Autoridades de Usuarios
Gestión de roles y permisos de usuarios


Excepciones de Seguridad
Manejo y personalización de excepciones de seguridad


Probando APIs Aseguradas
Asegurar que las medidas de seguridad funcionen como se pretende


Cuándo y Dónde Usar Autenticación JWT
La autenticación basada en JWT es ideal para aplicaciones sin estado, microservicios y escenarios donde la escalabilidad es esencial. Permite la transmisión segura de información entre partes y es ampliamente adoptada debido a su simplicidad y efectividad en el manejo de autenticación y autorización.

Comprendiendo Spring Security
Spring Security es un framework poderoso y altamente personalizable diseñado para manejar autenticación y autorización en aplicaciones Java. Se integra perfectamente con Spring Boot, proporcionando características de seguridad completas desde el inicio.
Características Clave de Spring Security

Autenticación y Autorización: Maneja los procesos de inicio de sesión de usuarios y los controles de acceso a recursos.
Soporte Integral: Soporta varios mecanismos de autenticación, incluyendo basada en formularios, OAuth2 y LDAP.
Extensibilidad: Fácilmente personalizable para adaptarse a requisitos de seguridad específicos.
Protección Contra Amenazas Comunes: Protege contra ataques como CSRF, fijación de sesión y más.

Configurando Spring Security en Spring Boot
Para integrar Spring Security en tu proyecto de Spring Boot, sigue estos pasos:

Agregar Dependencia: Incluye la dependencia de Spring Security en tu 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 Ajustes de Seguridad: Crea una clase de configuración de seguridad para definir comportamientos de seguridad.





		
		
			
			
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 Servicio de Detalles de Usuario: Implementa un servicio para cargar datos específicos del usuario.





		
		
			
			
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("User not found");
        }
        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("User not found");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), new ArrayList&lt;&gt;());
    }
}
 
					
				
			
		


Beneficios de Usar Spring Security

Seguridad Integral: Ofrece una amplia gama de características de seguridad desde el inicio.
Facilidad de Integración: Se integra sin problemas con aplicaciones de Spring Boot.
Personalizable: Altamente adaptable para satisfacer necesidades de seguridad específicas.
Comunidad Activa y Soporte: Bien documentado con un fuerte respaldo de la comunidad.


Autenticación Basada en Token con JWT
JSON Web Tokens (JWT) proporcionan un método sin estado y escalable para manejar autenticación y autorización. A diferencia de la autenticación tradicional basada en sesiones, JWT elimina la necesidad de sesiones en el lado del servidor, mejorando el rendimiento y la escalabilidad.
¿Qué es JWT?
JWT es un medio compacto y seguro para representar reclamaciones que se transfieren entre dos partes. El token consiste en tres partes:

Header: Especifica el tipo de token y el algoritmo de hash.
Payload: Contiene las reclamaciones o datos.
Signature: Asegura la integridad del token.

Cómo Funciona JWT en la Autenticación

Inicio de Sesión del Usuario: El usuario envía credenciales al servidor.
Generación de Token: Tras una autenticación exitosa, el servidor genera un JWT y se lo envía al usuario.
Almacenamiento del Token: El cliente almacena el JWT (comúnmente en almacenamiento local o cookies).
Solicitudes Autenticadas: El cliente incluye el JWT en el encabezado de Autorización para solicitudes posteriores.
Verificación del Token: El servidor verifica la validez del JWT y concede o niega el acceso basado en las reclamaciones del token.

Ventajas de Usar JWT

Sin Estado: No es necesario almacenar información de sesión en el servidor.
Escalable: Adecuado para sistemas distribuidos y microservicios.
Seguro: Puede ser firmado y encriptado para asegurar la integridad y confidencialidad de los datos.
Flexible: Soporta diversas estructuras de payload para adaptarse a diferentes casos de uso.

Implementando JWT en Spring Boot
Para implementar autenticación basada en JWT en Spring Boot:

Generar JWT: Crea tokens tras una autenticación exitosa.





		
		
			
			
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: Verifica la integridad y expiración del 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 en Solicitudes: Incluye el token en el encabezado de Autorización.





		
		
			
			
Java
			
			Authorization: Bearer &lt;token&gt;

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



Implementando Configuraciones de Seguridad
Configurar Spring Security es crucial para definir cómo tu aplicación maneja las preocupaciones de seguridad. Esta sección describe la configuración de las configuraciones de seguridad para habilitar la autenticación basada en JWT.
Creando la Clase de Configuración de Seguridad
La clase de configuración de seguridad extiende WebSecurityConfigurerAdapter para personalizar el comportamiento de seguridad.




		
		
			
			
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);
    }
}
 
					
				
			
		


Definiendo el Filtro de Solicitud JWT
El filtro de solicitud JWT intercepta las solicitudes entrantes para validar el 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 la Gestión de Sesiones
Establecer la política de creación de sesiones como sin estado garantiza que el servidor no almacene ninguna información de sesión, alineándose con la naturaleza sin estado de JWT.




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

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


Resumen de las Configuraciones de Seguridad

Deshabilitar CSRF: Dado que JWT es inmune a ataques CSRF, es común deshabilitar la protección CSRF para APIs.
Permitir Todo para Endpoints de Autenticación: Permite el acceso abierto a endpoints de autenticación como /auth/login y /auth/signup.
Autorizar Solicitudes Basadas en Roles/Autoridades: Restringe el acceso a endpoints específicos basados en roles o autoridades de usuario.
Agregar Filtro JWT: Integra el filtro de solicitud JWT para validar tokens en solicitudes entrantes.
Establecer Política de Sesión como Sin Estado: Asegura que no se almacenen datos de sesión en el servidor, manteniendo la naturaleza sin estado de JWT.


Creando el Auth Controller
El Auth Controller maneja los procesos de autenticación de usuarios, incluyendo el inicio de sesión y la generación de tokens. Sirve como el punto de entrada para que los usuarios obtengan JWTs tras una autenticación exitosa.
Implementando el 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("Incorrect username or password", 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 crear un nuevo usuario
        return ResponseEntity.ok("Usuario registrado exitosamente");
    }
}

			
				
					
				
					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("Incorrect username or password", 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 crear un nuevo usuario
        return ResponseEntity.ok("Usuario registrado exitosamente");
    }
}
 
					
				
			
		


Explicación del AuthController

Endpoint de Inicio de Sesión (/auth/login):

  - Autenticación: Valida las credenciales del usuario utilizando el AuthenticationManager.

  - Generación de JWT: Tras una autenticación exitosa, genera un JWT usando la clase JwtUtil.

  - Respuesta: Retorna el JWT encapsulado en un objeto TokenDTO.
Endpoint de Registro (/auth/signup):

  - Registro de Usuarios: Maneja la lógica para registrar un nuevo usuario.

  - Respuesta: Confirma el registro exitoso.

Clases DTO
UserLoginDTO




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

    // Getters y Setters
}

			
				
					
				
					1
2
3
4
5
6
7
				
						public class UserLoginDTO {
    private String username;
    private String password;
 
    // Getters y 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 y Setters
}

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


Manejo de Excepciones de Autenticación
Personalizar las excepciones de autenticación mejora la claridad de los mensajes de error y la experiencia del usuario.




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(BadCredentialsException.class)
    public ResponseEntity&lt;?&gt; handleBadCredentialsException(BadCredentialsException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Nombre de usuario o contraseña incorrectos");
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Ocurrió un error");
    }
}

			
				
					
				
					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("Nombre de usuario o contraseña incorrectos");
    }
 
    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Ocurrió un error");
    }
}
 
					
				
			
		



Administrando Roles y Autoridades de Usuarios
La gestión efectiva de roles y autoridades de usuarios asegura que los usuarios tengan niveles de acceso apropiados dentro de la aplicación. Spring Security distingue entre roles y autoridades, proporcionando un control granular sobre el acceso a recursos.
Comprendiendo Roles vs. Autoridades

Roles: Categoría amplia de usuarios (p.ej., USER, ADMIN). Comúnmente prefijados con ROLE_.
Autoridades: Permisos específicos asignados a usuarios (p.ej., READ_PRIVILEGES, WRITE_PRIVILEGES).

Configurando Roles y Autoridades en 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);
}
 
					
				
			
		


Asignando Roles a Usuarios
Al crear o actualizar cuentas de usuarios, asigna los roles apropiados.




		
		
			
			
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);
}
 
					
				
			
		


Configuración de Datos Iniciales
Los datos iniciales inicializan la base de datos con usuarios y roles predefinidos.




		
		
			
			
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);
    }
}
 
					
				
			
		


Manejo de Múltiples Autoridades
Los usuarios pueden poseer múltiples autoridades, proporcionando un control de acceso flexible.




		
		
			
			
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);
}
 
					
				
			
		


Resumen

Roles y Autoridades: Usa roles para acceso amplio y autoridades para permisos específicos.
Asignación: Asigna roles y autoridades durante la creación o actualización de usuarios.
Configuración: Define reglas de acceso en la configuración de seguridad basadas en roles y autoridades.
Flexibilidad: Implementa múltiples autoridades para satisfacer requisitos complejos de control de acceso.


Manejo de Excepciones de Seguridad
Manejar adecuadamente las excepciones de seguridad mejora la robustez de tu aplicación, proporcionando retroalimentación clara a los usuarios y manteniendo la integridad de la aplicación.
Excepciones Comunes de Seguridad

401 Unauthorized: Indica que la solicitud carece de credenciales de autenticación válidas.
403 Forbidden: Indica que el servidor entiende la solicitud pero se niega a autorizarla.

Personalizando Respuestas de Excepción




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

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

    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Alcance o permisos 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, verifica tu token de acceso");
    }
 
    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Alcance o permisos insuficientes");
    }
}
 
					
				
			
		


Actualizando Configuraciones de Seguridad para Manejar Excepciones




		
		
			
			
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, verifica tu token de acceso");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Alcance o permisos 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, verifica tu token de acceso");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Alcance o permisos insuficientes");
        })
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


Mejorando la Documentación de Swagger con Respuestas de Seguridad
Al documentar APIs usando Swagger, incluye respuestas relacionadas con seguridad para informar a los usuarios sobre posibles estados de error.




		
		
			
			
Java
			
			@Operation(summary = "Listar todos los usuarios", responses = {
    @ApiResponse(responseCode = "200", description = "Lista recuperada exitosamente"),
    @ApiResponse(responseCode = "401", description = "No autorizado - Por favor, verifica tu token de acceso"),
    @ApiResponse(responseCode = "403", description = "Prohibido - Alcance o permisos 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 los usuarios", responses = {
    @ApiResponse(responseCode = "200", description = "Lista recuperada exitosamente"),
    @ApiResponse(responseCode = "401", description = "No autorizado - Por favor, verifica tu token de acceso"),
    @ApiResponse(responseCode = "403", description = "Prohibido - Alcance o permisos insuficientes")
})
@GetMapping("/users")
public List&lt;User&gt; getAllUsers() {
    return userService.getAllUsers();
}
 
					
				
			
		


Resumen del Manejo de Excepciones

Mensajes Claros: Proporciona mensajes de error amigables para distintos tipos de excepciones.
Manejo Centralizado: Usa @ControllerAdvice para gestionar excepciones globalmente.
Integración con Swagger: Documenta posibles excepciones de seguridad en la documentación de la API.
Mantener la Seguridad: Evita exponer información sensible a través de los mensajes de error.


Probando la API Asegurada
Asegurar que tus configuraciones de seguridad funcionen como se pretende es crucial. Esta sección cubre estrategias de prueba para validar mecanismos de autenticación y autorización.
Probando el Flujo de Autenticación

Intentar Acceso No Autorizado:

  - Acción: Acceder a un endpoint asegurado sin un token.

  - Resultado Esperado: Recibir una respuesta 401 Unauthorized.
Iniciar Sesión con Credenciales Válidas:

  - Acción: Enviar una solicitud POST a /auth/login con credenciales válidas.

  - Resultado Esperado: Recibir un JWT en la respuesta.
Iniciar Sesión con Credenciales Inválidas:

  - Acción: Enviar una solicitud POST a /auth/login con credenciales inválidas.

  - Resultado Esperado: Recibir una respuesta 401 Unauthorized con un mensaje de error.

Probando el Flujo de Autorización

Acceder con Token Válido:

  - Acción: Usar el JWT recibido para acceder a un endpoint asegurado.

  - Resultado Esperado: Acceso exitoso con datos apropiados.
Acceder con Token Inválido:

  - Acción: Usar un JWT inválido o manipulado.

  - Resultado Esperado: Recibir una respuesta 401 Unauthorized.
Acceder con Permisos Insuficientes:

  - Acción: Usar un JWT sin las autoridades necesarias para acceder a un endpoint restringido.

  - Resultado Esperado: Recibir una respuesta 403 Forbidden.

Usando Swagger para Pruebas
Swagger UI es una excelente herramienta para probar tus APIs interactivamente.

Generar Token:

  - Navega al endpoint /auth/login.

  - Proporciona credenciales válidas para recibir un JWT.
Autorizar en Swagger:

  - Haz clic en el botón "Autorizar" en Swagger.

  - Ingresa el JWT como Bearer <token>.
Acceder a Endpoints Asegurados:

  - Intenta acceder a endpoints como /users o /admin.

  - Observa las respuestas basadas en la validez y permisos del token.

Pruebas Automatizadas con Postman
Postman puede automatizar y simplificar las pruebas de APIs.

Configurar Colecciones:

  - Crea solicitudes para inicio de sesión, acceder a endpoints asegurados, etc.
Usar Variables de Entorno:

  - Almacena y reutiliza tokens a través de solicitudes.
Asumir Respuestas:

  - Define respuestas esperadas para diferentes escenarios.

Fragmentos de Código de Ejemplo para Pruebas
Probando Acceso No Autorizado




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

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


Respuesta Esperada:




		
		
			
			
Java
			
			401 Unauthorized - Por favor, verifica tu token de acceso

			
				
					
				
					1
2
				
						401 Unauthorized - Por favor, verifica tu token de acceso
 
					
				
			
		


Probando Acceso 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;"
 
					
				
			
		


Respuesta 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]"
    }
]
 
					
				
			
		


Resumen

Pruebas Integrales: Valida tanto los flujos de autenticación como de autorización.
Usar Herramientas de Manera Efectiva: Aprovecha Swagger y Postman para facilitar las pruebas.
Automatizar Cuando Sea Posible: Implementa pruebas automatizadas para asegurar chequeos de seguridad consistentes.
Monitorear Respuestas: Asegura que las respuestas alineen con los comportamientos de seguridad esperados.


Conclusión
Asegurar APIs es un aspecto fundamental del desarrollo de aplicaciones modernas, protegiendo datos sensibles y garantizando que solo usuarios autorizados puedan acceder a recursos protegidos. Al integrar Spring Security con autenticación basada en token JWT, los desarrolladores pueden implementar mecanismos de seguridad robustos, escalables y eficientes en sus aplicaciones de Spring Boot.
A lo largo de este eBook, hemos explorado los conceptos fundamentales de Spring Security, la mecánica de la autenticación JWT, las complejidades de configurar ajustes de seguridad, gestionar roles y autoridades de usuarios, manejar excepciones de seguridad y probar eficazmente APIs aseguradas. Cada componente desempeña un papel vital en la construcción de un ecosistema de API seguro.
Puntos Clave

Integración de Spring Security: Se integra sin problemas con Spring Boot para proporcionar características de seguridad completas.
Autenticación JWT: Ofrece un método sin estado y escalable para manejar la autenticación y autorización de usuarios.
Gestión de Roles y Autoridades: Permite un control detallado sobre los permisos y niveles de acceso de los usuarios.
Manejo de Excepciones: Asegura que los errores relacionados con la seguridad se gestionen de manera elegante e informativa.
Pruebas Exhaustivas: Valida la efectividad de las implementaciones de seguridad, previniendo vulnerabilidades potenciales.

A medida que las aplicaciones continúan evolucionando, mantener y mejorar las medidas de seguridad sigue siendo una tarea continua. Mantenerse informado sobre las mejores prácticas, amenazas emergentes y soluciones innovadoras es esencial para los desarrolladores comprometidos con la construcción de aplicaciones seguras y confiables.
Llamado a la Acción
Potencia tu flujo de trabajo de desarrollo implementando las estrategias de seguridad descritas en este eBook. Comienza integrando Spring Security y JWT en tus proyectos de Spring Boot, y refina continuamente tu postura de seguridad para adaptarte a desafíos en evolución. Para un aprendizaje adicional, explora temas avanzados como la integración de OAuth2, autenticación multifactor y auditoría de seguridad para profundizar tu experiencia en la seguridad de APIs.

Nota: Este artículo fue generado por IA.
Tema	Descripción
Spring Security	Visión general y configuración de Spring Security en proyectos de Spring Boot
Autenticación JWT	Comprensión e implementación de autenticación basada en tokens
Configuraciones de Seguridad	Configuración de ajustes de seguridad para APIs
Auth Controller	Creación de controladores para manejar procesos de autenticación
Roles y Autoridades de Usuarios	Gestión de roles y permisos de usuarios
Excepciones de Seguridad	Manejo y personalización de excepciones de seguridad
Probando APIs Aseguradas	Asegurar que las medidas de seguridad funcionen como se pretende