SpringBoot
Tutorial SpringBoot: Verificar token JWT en peticiones
Spring JWT filtro: implementación y uso. Domina la implementación de filtros JWT en Spring con ejemplos prácticos y detallados.
Introducción
Crear un filtro para interceptar las peticiones HTTP entrantes a los controladores REST de Spring Boot.
Este filtro será el encargado de:
- Detectar la cabecera
Authorization
. - Extraer el
token JWT
de la cabeceraAuthorization
. - Verificar la firma del token, debe estar firmado por el backend con la misma clave secreta.
- Decodificar el token y extraer el payload, por ejemplo el id del usuario.
- Comprobar que existe el usuario y obtenerlo.
- Cargar el usuario en el contexto de seguridad de Spring Security para notificar a Spring del usuario autenticado.
Crear filtro Spring
Se crea una clase Java que extiende de OncePerRequestFilter
:
@Component
@AllArgsConstructor
@Slf4j
public class RequestJWTFilter extends OncePerRequestFilter {
private final UserRepository userRepository;
@Override
protected void doFilterInternal(
HttpServletRequest request,
HttpServletResponse response,
FilterChain filterChain) throws ServletException, IOException {
// 1. Extraer de la cabecera Authorization de la request
String bearerToken = request.getHeader("Authorization");
if (!StringUtils.hasLength(bearerToken) || !bearerToken.startsWith("Bearer")) {
filterChain.doFilter(request, response);
return;
}
String token = bearerToken.substring("Bearer ".length());
// 2. Verificar el token JWT
Optional<User> userOptional = validateTokenAndExtractUser(token);
if (userOptional.isEmpty()) {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
return;
}
// 3. Cargar usuario en contexto de seguridad Spring
User user = userOptional.get();
SimpleGrantedAuthority role = new SimpleGrantedAuthority(user.getRole().toString());
Authentication auth = new UsernamePasswordAuthenticationToken(user, null, List.of(role));
SecurityContextHolder.getContext().setAuthentication(auth);
filterChain.doFilter(request, response);
}
private Optional<User> validateTokenAndExtractUser(String token) {
byte[] key = Base64.getDecoder().decode("FZD5maIaX04mYCwsgckoBh1NJp6T3t62h2MVyEtdo3w=");
try {
String userId = Jwts.parser()
.verifyWith(Keys.hmacShaKeyFor(key))
.build()
.parseSignedClaims(token)
.getPayload()
.getSubject();
return this.userRepository.findById(Long.valueOf(userId));
} catch (JwtException e) {
log.error("Error en la validación del token JWT");
return Optional.empty();
}
}
}
Crear clase SecurityConfig
Esta clase configura la seguridad globalmente:
import lombok.AllArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@AllArgsConstructor
@Configuration
public class SecurityConfig {
private final RequestJWTFilter jwtFilter;
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
// Para versiones >= 6.1 de Spring Security
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
return http
.csrf(csrf -> csrf.disable())
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(authorizeHttpRequests -> authorizeHttpRequests
.requestMatchers("/users/login").permitAll()
.requestMatchers("/users/register").permitAll()
.requestMatchers("files/**").permitAll()
.requestMatchers(HttpMethod.POST, "books").hasAnyAuthority("ADMIN")
.requestMatchers(HttpMethod.PUT, "books").hasAnyAuthority("ADMIN")
.requestMatchers(HttpMethod.DELETE, "books").hasAnyAuthority("ADMIN")
.anyRequest().authenticated()
).addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
.build();
}
Crear clase SecurityUtils
Con esta clase creamos un método getCurrentUser() o getAuthenticatedUser() que devuelva el usuario autenticado guardado en el contexto de seguridad:
import com.certidevs.model.User;
import org.springframework.security.core.context.SecurityContextHolder;
import java.util.Optional;
public class SecurityUtils {
private SecurityUtils() {}
/**
* Devuelve el usuario autenticado extraído de Spring Security
*
* Se utiliza así:
*
* User user = SecurityUtils.getCurrentUser().orElseThrow();
* @return
*/
public static Optional<User> getCurrentUser() {
Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
if (principal instanceof User user) {
return Optional.of(user);
} else {
return Optional.empty();
}
}
public static boolean isAdminCurrentUser() {
if (getCurrentUser().isEmpty()) {
return false;
}
User user = getCurrentUser().get();
return user.getRole().equals(Role.ADMIN);
}
}
Esta clase permite obtener el usuario en cualquier lugar de la aplicación backend, como por ejemplo controladores o servicios.
En este ejemplo se utiliza para obtener el usuario autenticado y asignarlo a una reserva en un controlador:
Clase ReservationController:
@CrossOrigin("*") // Permitir acceso desde cualquier dominio desde el exterior
@RestController
@AllArgsConstructor
@Slf4j
public class ReservationController {
private final ReservationRepository repo;
@PostMapping("reservations")
public Reservation create(@RequestBody Reservation reservation){
SecurityUtils.getCurrentUser().ifPresent(user -> reservation.setUser(user));
return this.repo.save(reservation);
}
}
Otro ejemplo sería actualizar la propia cuenta del usuario desde el frontend:
@PutMapping("users/account")
public User update(@RequestBody User user) {
// Si está autenticado, y el usuario autenticado es ADMIN o es el mismo usuario que la variable user
// entonces actualizar, en caso contrario no actualizamos
SecurityUtils.getCurrentUser().ifPresent(currentUser -> {
if (currentUser.getRole() == Role.ADMIN || Objects.equals(currentUser.getId(), user.getId())) {
this.userRepository.save(user);
} else {
throw new RuntimeException("No puede actualizar"); // Reemplazar por Excepción personalizada
}
});
return user;
}
Ejercicios de esta lección Verificar token JWT en peticiones
Evalúa tus conocimientos de esta lección Verificar token JWT en peticiones con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Web y Test Starters
Entidades JPA
Repositorios reactivos
Inserción de datos
Borrar datos de base de datos
Controladores Spring MVC
Backend API REST con Spring Boot
Operadores Reactivos
Controladores Spring REST
Uso de Spring con Thymeleaf
Crear entidades JPA
Registro de usuarios
CRUD y JPA Repository
Anotaciones y mapeo en JPA
Integración con Vue
Consultas JPQL con @Query en Spring Data JPA
Open API y cómo agregarlo en Spring Boot
Uso de Controladores REST
API Specification
Inyección de dependencias
Introducción a Spring Boot
Consultas JPQL con @Query en Spring Data JPA
API Query By Example (QBE)
Inyección de dependencias
Vista en Spring MVC con Thymeleaf
Servicios en Spring
Configuración de Vue
Integración con Angular
API Query By Example (QBE)
API Specification
Controladores MVC
Métodos find en repositorios
Repositorios Spring Data
Inyección de dependencias
Data JPA y Mail Starters
Configuración de Angular
Controladores Spring REST
Configuración de Controladores MVC
Asociaciones de entidades JPA
Actualizar datos de base de datos
Identificadores y relaciones JPA
Verificar token JWT en peticiones
Login de usuarios
Integración con React
Configuración de React
Asociaciones en JPA
Consultas JPQL
Todas las lecciones de SpringBoot
Accede a todas las lecciones de SpringBoot y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Spring Boot
Introducción Y Entorno
Spring Boot Starters
Introducción Y Entorno
Inyección De Dependencias
Introducción Y Entorno
Controladores Spring Mvc
Spring Web
Vista En Spring Mvc Con Thymeleaf
Spring Web
Controladores Spring Rest
Spring Web
Open Api Y Cómo Agregarlo En Spring Boot
Spring Web
Servicios En Spring
Spring Web
Crear Entidades Jpa
Persistencia Con Spring Data
Asociaciones De Entidades Jpa
Persistencia Con Spring Data
Repositorios Spring Data
Persistencia Con Spring Data
Métodos Find En Repositorios
Persistencia Con Spring Data
Inserción De Datos
Persistencia Con Spring Data
Actualizar Datos De Base De Datos
Persistencia Con Spring Data
Borrar Datos De Base De Datos
Persistencia Con Spring Data
Consultas Jpql Con @Query En Spring Data Jpa
Persistencia Con Spring Data
Api Query By Example (Qbe)
Persistencia Con Spring Data
Repositorios Reactivos
Persistencia Con Spring Data
Api Specification
Persistencia Con Spring Data
Integración Con React
Integración Frontend
Integración Con Vue
Integración Frontend
Integración Con Angular
Integración Frontend
Registro De Usuarios
Seguridad Con Spring Security
Login De Usuarios
Seguridad Con Spring Security
Verificar Token Jwt En Peticiones
Seguridad Con Spring Security
En esta lección
Objetivos de aprendizaje de esta lección
- Crear un filtro que intercepte las peticiones HTTP
- Verificar el token JWT de las peticiones
- Identificar el usuario a partir del token JWT
- Cargar el usuario en el contexto de seguridad de Spring Security