8. Autenticación y autorización
Para cada solicitud se plantean dos preguntas distintas:
- ¿Quién es el usuario? Esto es la autenticación: el usuario se ha identificado con un nombre de usuario y una contraseña, y cada solicitud posterior debe probar que proviene de él;
- ¿Tiene el usuario permiso para acceder a esta página? Esto es la autorización: en el caso de estudio, solo un usuario con el rol ADMIN administra los médicos y los clientes.
Como el servidor no tiene estado (capítulo 6), la prueba de identidad debe incluirse en cada solicitud. Se utiliza un token JWT ([JSON Web Token]): después del inicio de sesión, el servidor genera un token que contiene la identidad del usuario y lo firma con una clave secreta. El token se almacena en una cookie; el navegador lo reenvía con cada solicitud; el servidor verifica la firma. El usuario puede leer su token, pero no puede modificarlo: cualquier modificación invalida la firma.
Con [Spring], estas dos cuestiones están a cargo de [Spring Security], un proyecto de la familia [Spring] distinto de [Spring MVC]. [Spring Security] es una cadena de filtros de servlet (véase el capítulo 7), situada antes de [DispatcherServlet]: cada solicitud pasa por ella antes de llegar a [Spring MVC].
- la autenticación está a cargo de un filtro que busca un token en la solicitud, lo verifica y deduce el usuario autenticado: un objeto [Authentication] almacenado en el contexto de seguridad de la solicitud. Para los tokens JWT, este filtro lo proporciona el componente "resource server" ([resource server]) de [Spring Security], cuyo nombre proviene del protocolo [OAuth2]: un servidor de recursos es un servidor que acepta tokens generados por otro servidor (en este caso, por sí mismo);
- la autorización está a cargo de otro filtro, que aplica reglas escritas en [Java] para cada URL ("esta dirección es pública", "esta requiere un usuario autenticado") y anotaciones aplicadas a los controladores ([@PreAuthorize], ejemplo 26).
Los ejemplos de este capítulo usan un starter más: [spring-boot-starter-security-oauth2-resource-server]. Incluye [Spring Security], su componente "resource server" y la biblioteca [Nimbus JOSE + JWT], que genera y verifica los tokens. El hash de contraseñas ([bcrypt]) forma parte de [Spring Security]: no hay que declarar otras bibliotecas. [Maven] descarga estas bibliotecas durante la primera compilación; por lo tanto, se requiere una conexión a Internet.
8.1. Ejemplo 25: Inicio de sesión, token, página protegida
| 25-jwt/
├── src/
│ └── main/
│ ├── java/
│ │ └── example25/
│ │ ├── auth/
│ │ │ ├── AuthService.java
│ │ │ ├── JwtProperties.java
│ │ │ └── UsersService.java
│ │ ├── config/
│ │ │ ├── SecurityConfig.java
│ │ │ └── WebConfig.java
│ │ ├── controllers/
│ │ │ ├── AuthController.java
│ │ │ └── ProfileController.java
│ │ └── Example25Application.java
│ └── resources/
│ ├── templates/
│ │ ├── auth/
│ │ │ └── login.html
│ │ ├── profile/
│ │ │ └── profile.html
│ │ └── layout.html
│ └── application.properties
└── pom.xml
|
El archivo [pom.xml]:
| <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>course.springmvc</groupId>
<artifactId>examples</artifactId>
<version>1.0</version>
</parent>
<artifactId>example25</artifactId>
<dependencies>
<!-- las vistas Thymeleaf -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!-- Spring Security, con autenticación mediante token JWT (creación y verificación de los tokens) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security-oauth2-resource-server</artifactId>
</dependency>
</dependencies>
</project>
|
- líneas 15-18: las vistas [Thymeleaf];
- líneas 20-23: [Spring Security] y la autenticación basada en tokens JWT. En cuanto [Spring Security] está presente en el proyecto, [Spring Boot] protege todas las URL de la aplicación de forma predeterminada. Es la clase de configuración [SecurityConfig], que se muestra más adelante, la que establece nuestras propias reglas.
El archivo [application.properties]:
| # el puerto de escucha del servidor (8080 por defecto)
server.port=5000
# las respuestas de error de Spring Boot no contienen la pila de llamadas
spring.web.error.include-stacktrace=never
# la clave que firma los tokens JWT (al menos 32 caracteres), y su duración
jwt.secret=a-secret-key-of-at-least-32-characters-for-example-25
jwt.duration-minutes=60
|
- líneas 6-7: dos propiedades específicas de la aplicación: la clave que firma los tokens y su duración. Cualquiera que conozca la clave puede generar tokens válidos: en producción, no se almacena en un archivo del proyecto; en su lugar, la proporciona una variable de entorno ([JWT_SECRET], que tiene prioridad sobre el archivo) o una bóveda de secretos. El algoritmo utilizado (HMAC-SHA256) requiere una clave de al menos 32 bytes (256 bits): [Nimbus] se niega a firmar con una clave más corta.
El archivo [auth/JwtProperties.java]:
| package example25.auth;
import org.springframework.boot.context.properties.ConfigurationProperties;
// las propiedades [jwt.*] de application.properties, almacenadas en un record:
// jwt.secret -> secret; jwt.duration-minutes -> durationMinutes
@ConfigurationProperties("jwt")
public record JwtProperties(String secret, int durationMinutes) {
}
|
- líneas 7-8: la anotación [@ConfigurationProperties("jwt")] indica a [Spring Boot] que llene este record con las propiedades que comienzan con [jwt.]: [jwt.secret] va al componente [secret] y [jwt.duration-minutes] va al componente [durationMinutes] (los guiones se ignoran, igual que las mayúsculas: este es el enlace flexible de [Spring Boot]). El valor [60] se convierte a [int]; un valor que no sea un número haría que la aplicación terminara de inmediato al iniciar, con un mensaje de error claro. El record se convierte en un bean, que se recibe mediante inyección como cualquier otro servicio. Se declara mediante la anotación [@EnableConfigurationProperties] de [SecurityConfig] (más adelante).
Habríamos podido leer cada propiedad con la anotación [@Value("${jwt.secret}")]; el record agrupa las propiedades de un mismo tema y asigna un tipo a cada una.
El archivo [auth/UsersService.java]:
| package example25.auth;
import java.util.List;
import java.util.Optional;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
// los usuarios, en memoria (el próximo capítulo los pondrá en una base de datos)
@Service
public class UsersService {
public record User(String login, String name, String role, String passwordHash) {
}
private final List<User> users;
// PasswordEncoder: el hash de las contraseñas (bcrypt, vea SecurityConfig)
public UsersService(PasswordEncoder hashing) {
// una contraseña NUNCA se conserva, solo su hash
users = List.of(
new User("marie", "Marie Pélissier", "USER", hashing.encode("marie")),
new User("admin", "Administrator", "ADMIN", hashing.encode("admin")));
}
public Optional<User> find(String login) {
return users.stream().filter(u -> u.login().equals(login)).findFirst();
}
}
|
- líneas 13-14: un usuario, junto con su rol, en forma de un record anidado dentro del servicio;
- líneas 19-24: nunca se almacena una contraseña; solo se conserva su hash, un valor calculado por una función unidireccional. Es posible verificar que una contraseña coincide con un hash, pero no recuperar la contraseña a partir del hash. El servicio recibe mediante inyección un [PasswordEncoder], la interfaz de [Spring Security] para el hash de contraseñas, y lo usa para generar los hashes de las dos cuentas de prueba (línea 22);
- líneas 26-28: la búsqueda de un usuario por su nombre de usuario devuelve un [Optional<User>], un contenedor que guarda un usuario o está vacío. La lista se recorre como un stream ([stream()]): [filter] conserva solo los elementos que cumplen la condición, y [findFirst] devuelve el primero (dentro de un [Optional]).
El archivo [auth/AuthService.java]:
| package example25.auth;
import java.time.Duration;
import java.time.Instant;
import java.util.Optional;
import org.springframework.http.ResponseCookie;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.jose.jws.MacAlgorithm;
import org.springframework.security.oauth2.jwt.JwsHeader;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
import org.springframework.stereotype.Service;
import example25.auth.UsersService.User;
@Service
public class AuthService {
// el nombre de la cookie que transporta el token
public static final String COOKIE = "token";
private final UsersService users;
private final PasswordEncoder hashing;
private final JwtEncoder encoder;
private final JwtProperties properties;
public AuthService(UsersService users, PasswordEncoder hashing, JwtEncoder encoder,
JwtProperties properties) {
this.users = users;
this.hashing = hashing;
this.encoder = encoder;
this.properties = properties;
}
// el usuario, o "nada" si el login es desconocido o la contraseña es incorrecta
public Optional<User> validate(String login, String password) {
if (login == null || password == null) {
return Optional.empty();
}
return users.find(login).filter(u -> hashing.matches(password, u.passwordHash()));
}
// el token JWT del usuario, firmado con la clave secreta
public String createToken(User user) {
Instant now = Instant.now();
// el contenido del token: los "claims" (afirmaciones sobre el usuario)
JwtClaimsSet claims = JwtClaimsSet.builder()
.subject(user.login())
.claim("name", user.name())
.claim("role", user.role())
.issuedAt(now)
.expiresAt(now.plus(duration()))
.build();
// el encabezado: el algoritmo de firma (HMAC-SHA256)
JwsHeader header = JwsHeader.with(MacAlgorithm.HS256).build();
return encoder.encode(JwtEncoderParameters.from(header, claims)).getTokenValue();
}
// la cookie que transporta el token: el JavaScript de la página no puede leerla
public ResponseCookie cookie(String token) {
return ResponseCookie.from(COOKIE, token).path("/").httpOnly(true).sameSite("Lax").maxAge(duration()).build();
}
private Duration duration() {
return Duration.ofMinutes(properties.durationMinutes());
}
}
|
Comentemos este código:
- línea 22: el nombre de la cookie que transporta el token;
- líneas 29-35: el servicio recibe en su constructor el servicio de usuarios, el codificador de contraseñas, el codificador de tokens [JwtEncoder], y las propiedades [jwt.*]. Estos tres últimos beans se declaran en [SecurityConfig];
- líneas 38-43: verificación del nombre de usuario y la contraseña. [Optional.filter] vacía el contenedor si la condición es falsa: el resultado contiene al usuario solo si el nombre de usuario existe y si [hashing.matches(password, hash)] reconoce la contraseña;
- líneas 49-55: el contenido del token, los claims (afirmaciones sobre el usuario). [subject] (el claim [sub]) es el nombre convencional del identificador del usuario. Aquí incluimos lo que las páginas necesitan (nombre, rol), para no tener que consultar la base de datos en cada solicitud. [issuedAt] y [expiresAt] proporcionan los claims [iat] (fecha de creación) y [exp] (fecha de expiración);
- línea 57: el encabezado del token, que especifica el algoritmo de firma: HMAC-SHA256, denotado como [HS256];
- línea 58: el codificador genera el token firmado; [getTokenValue()] lo convierte a su forma de texto;
- líneas 62-64: la cookie que transporta el token, generada por la clase [ResponseCookie] de [Spring]: [httpOnly(true)] impide que el [JavaScript] de la página la lea, lo que protege el token si se ejecutara un script malicioso en la página; [sameSite("Lax")] impide que el navegador la incluya en las solicitudes POST enviadas desde otro sitio (véase más adelante la protección [CSRF]); [maxAge] establece la duración de la cookie para que coincida con la del token.
El archivo [config/SecurityConfig.java] es el núcleo de este ejemplo. Su primera parte declara los beans necesarios para la seguridad:
| package example25.config;
import java.nio.charset.StandardCharsets;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.ResponseCookie;
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.oauth2.jose.jws.MacAlgorithm;
import org.springframework.security.oauth2.jwt.JwtDecoder;
import org.springframework.security.oauth2.jwt.JwtEncoder;
import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
import org.springframework.security.oauth2.server.resource.web.BearerTokenResolver;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.util.WebUtils;
import example25.auth.AuthService;
import example25.auth.JwtProperties;
import jakarta.servlet.http.Cookie;
// la configuración de Spring Security
@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {
// la clave que firma y verifica los tokens (algoritmo simétrico HMAC-SHA256)
@Bean
public SecretKey jwtKey(JwtProperties properties) {
return new SecretKeySpec(properties.secret().getBytes(StandardCharsets.UTF_8), "HmacSHA256");
}
// la construcción de los tokens (biblioteca Nimbus, incluida con Spring Security)
@Bean
public JwtEncoder jwtEncoder(SecretKey key) {
return NimbusJwtEncoder.withSecretKey(key).algorithm(MacAlgorithm.HS256).build();
}
// la verificación de los tokens: firma y fecha de expiración
@Bean
public JwtDecoder jwtDecoder(SecretKey key) {
return NimbusJwtDecoder.withSecretKey(key).macAlgorithm(MacAlgorithm.HS256).build();
}
// el hash de las contraseñas: bcrypt, con un costo de 10
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder(10);
}
|
- línea 33: una clase de configuración, cuyos métodos [@Bean] crean beans (véase el ejemplo 06);
- línea 34: registro del record [JwtProperties] como un bean, llenado a partir de [application.properties];
- líneas 38-41: la clave de firma, generada a partir del texto de la propiedad [jwt.secret]. Se usa la misma clave para firmar y verificar los tokens: el algoritmo es simétrico. Un método [@Bean] puede aceptar otros beans como parámetros: en este caso, las propiedades [jwt.*];
- líneas 44-47: el codificador de tokens, que firma mediante la clave. [NimbusJwtEncoder] se basa en la biblioteca [Nimbus];
- líneas 50-53: el decodificador, que verifica cada token recibido: primero la firma (con la misma clave) y luego la fecha de expiración (con una tolerancia de 60 segundos para relojes desincronizados). El filtro de autenticación lo usa en cada solicitud que lleva un token;
- líneas 56-59: hash de contraseñas con el algoritmo [bcrypt], con un "costo" de 10: [bcrypt] es deliberadamente lento (2¹⁰ ciclos de cálculo) para disuadir a quien quiera probar millones de contraseñas. Dos hashes de la misma contraseña son diferentes (se agrega una "sal" aleatoria): [matches] se encarga de verificarlos.
La segunda parte describe la cadena de filtros de seguridad:
| // la cadena de filtros de seguridad: quién puede acceder a qué, y cómo
// se reconoce al usuario
@Bean
public SecurityFilterChain securityFilters(HttpSecurity http) throws Exception {
http
// 1. las reglas de acceso, examinadas en orden
.authorizeHttpRequests(access -> access
.requestMatchers("/", "/login", "/error", "/bootstrap/**").permitAll()
.anyRequest().authenticated())
// 2. autenticación mediante token JWT (OAuth2 "resource server")
.oauth2ResourceServer(jwt -> jwt
.bearerTokenResolver(tokenFromCookie())
.authenticationEntryPoint(toLogin())
.jwt(config -> config.jwtAuthenticationConverter(converter())))
// 3. página protegida solicitada sin token: se redirige a la página de inicio de sesión
.exceptionHandling(errors -> errors.authenticationEntryPoint(toLogin()))
// 4. cierre de sesión (POST /logout): se elimina la cookie y luego se va a /login
.logout(logout -> logout.logoutUrl("/logout").deleteCookies(AuthService.COOKIE)
.logoutSuccessUrl("/login"))
// 5. el servidor es sin estado: sin sesión HTTP
.sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
// 6. sin token anti-CSRF: la cookie SameSite=Lax ya protege
// las solicitudes POST provenientes de otros sitios
.csrf(csrf -> csrf.disable());
return http.build();
}
// el token se lee de la cookie (y no del encabezado Authorization)
private static BearerTokenResolver tokenFromCookie() {
return request -> {
Cookie cookie = WebUtils.getCookie(request, AuthService.COOKIE);
return cookie == null ? null : cookie.getValue();
};
}
// ningún usuario autenticado (sin token, token inválido o expirado):
// eliminamos la posible cookie y redirigimos a la página de inicio de sesión
private static AuthenticationEntryPoint toLogin() {
return (request, response, exception) -> {
if (WebUtils.getCookie(request, AuthService.COOKIE) != null) {
response.addHeader("Set-Cookie", ResponseCookie.from(AuthService.COOKIE, "").path("/").maxAge(0).build().toString());
}
response.sendRedirect("/login");
};
}
// del token al usuario autenticado: el claim [name] es su nombre, el
// claim [role] su rol; Spring Security escribe los roles con el prefijo ROLE_
private static JwtAuthenticationConverter converter() {
JwtGrantedAuthoritiesConverter roles = new JwtGrantedAuthoritiesConverter();
roles.setAuthoritiesClaimName("role");
roles.setAuthorityPrefix("ROLE_");
JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
converter.setJwtGrantedAuthoritiesConverter(roles);
converter.setPrincipalClaimName("name");
return converter;
}
}
|
Analicemos este código:
- líneas 4-5: un bean de tipo [SecurityFilterChain]: la cadena de filtros de seguridad. [Spring Boot] proporciona un objeto [HttpSecurity], que configuramos, método por método, antes de construir la cadena (línea 26). Cada método recibe una lambda que configura una parte de los ajustes;
- líneas 8-10: las reglas de acceso para las URL, examinadas en el siguiente orden: [/], [/login], [/error] (la página de error de [Spring Boot]) y los archivos de [Bootstrap] son públicos ([permitAll()]); cualquier otra URL ([anyRequest()]) requiere un usuario autenticado. Por lo tanto, la página [/profile] está protegida, sin necesidad de escribir nada en su controlador;
- Líneas 12-15: autenticación basada en tokens JWT. De forma predeterminada, el resource server busca el token en el encabezado [Authorization: Bearer ...] de la solicitud: así funciona un cliente [JavaScript] o una aplicación móvil. Un navegador no agrega este encabezado por sí solo: se le indica que obtenga el token de la cookie (línea 13). La línea 15 cambia la forma en que el token se asigna a un usuario (véanse las líneas 50-58);
- líneas 14 y 17: el punto de entrada de autenticación ([authentication entry point]) se invoca cuando se solicita una página protegida sin un usuario autenticado. De forma predeterminada, la respuesta es un error 401 sin contenido: útil para un cliente [JavaScript], pero confuso para un usuario. Se redirige al usuario a la página de inicio de sesión. Esto se declara dos veces: el filtro del resource server llama directamente a su propio punto de entrada cuando la solicitud contiene un token que rechaza (línea 14); la línea 17 cubre el caso de una página protegida solicitada sin token;
- líneas 19-20: el cierre de sesión lo maneja [Spring Security] mismo, mediante un filtro ([LogoutFilter]) que intercepta [POST /logout]: elimina la cookie del token ([deleteCookies]) y redirige a [/login]. No se requiere ninguna acción de controlador;
- línea 22: [STATELESS]: [Spring Security] no crea una sesión (HTTP; véase el capítulo 6) y no la usa para recordar al usuario. El usuario se reconoce en cada solicitud únicamente por el token;
- línea 25: la protección [CSRF] ([Cross-Site Request Forgery], falsificación de solicitudes entre sitios) está deshabilitada. Un ataque [CSRF] consiste en que un sitio malicioso engañe al navegador de la víctima para que envíe un formulario POST a nuestro sitio: el navegador incluiría la cookie y la solicitud quedaría autenticada. De forma predeterminada, [Spring Security] exige un token anti-CSRF en cada formulario POST: un campo oculto que el sitio malicioso no puede conocer. Aquí basta con la cookie [SameSite=Lax]: el navegador no la incluye en una solicitud POST proveniente de otro sitio, por lo que esa solicitud llega sin un usuario autenticado. Sin embargo, ninguna solicitud GET con la cookie debe modificar datos (véase el ejemplo 21): una cookie [Lax] acompaña a los enlaces provenientes de otros sitios;
- Líneas 30-35: el resolvedor de tokens ([BearerTokenResolver]): una interfaz de un solo método, escrita aquí como una lambda, que devuelve el token de la solicitud o [null]. [WebUtils.getCookie] busca una cookie por nombre;
- Líneas 39-46: el punto de entrada: una redirección a [/login] (línea 44). Si la solicitud contenía una cookie [token], significa que el token no es válido (firma no válida) o ha expirado: la cookie se borra restableciéndola con un valor vacío y una duración de cero (líneas 41-43). Sin este paso, el navegador reenviaría el token rechazado con la solicitud [GET /login], que el filtro rechazaría a su vez, lo que daría lugar a un bucle de redirección;
- líneas 50-58: del token al usuario autenticado. Para [Spring Security], los permisos de un usuario son autoridades ([authorities]): simples cadenas de caracteres. De forma predeterminada, el resource server las lee del claim [scope] del token, con el prefijo [SCOPE_]. Aquí se leen del claim [role] (línea 52), con el prefijo [ROLE_] (línea 53), que [Spring Security] espera para un rol: el rol [USER] del token se convierte en la autoridad [ROLE_USER]. La línea 56 indica que el nombre del usuario ([Authentication.getName()]) es el claim [name], y no [sub].
Los filtros que [Spring Security] colocó en la cadena se escriben en la consola al iniciar, si se solicita el nivel de registro [DEBUG] para la clase [DefaultSecurityFilterChain]:
| ../mvnw spring-boot:run -Dspring-boot.run.arguments=--logging.level.org.springframework.security.web.DefaultSecurityFilterChain=debug
|
| ... DEBUG ... o.s.s.web.DefaultSecurityFilterChain : Will secure any request with filters: DisableEncodeUrlFilter, WebAsyncManagerIntegrationFilter, SecurityContextHolderFilter, HeaderWriterFilter, LogoutFilter, OAuth2ProtectedResourceMetadataFilter, BearerTokenAuthenticationFilter, RequestCacheAwareFilter, SecurityContextHolderAwareRequestFilter, AnonymousAuthenticationFilter, SessionManagementFilter, ExceptionTranslationFilter, AuthorizationFilter
|
Se pueden identificar, en particular, los siguientes:
- [HeaderWriterFilter], que agrega encabezados de seguridad ([X-Content-Type-Options: nosniff], [X-Frame-Options: DENY], [Cache-Control: no-cache, no-store...]) a cada respuesta: estos no se incluyen en las respuestas de este capítulo;
- [LogoutFilter], que procesa [/logout];
- [BearerTokenAuthenticationFilter], el filtro del resource server: lee el token (mediante nuestro resolvedor), lo verifica (mediante el decodificador) y coloca al usuario autenticado en el contexto de seguridad;
- [AnonymousAuthenticationFilter]: sin token, el usuario es "anónimo";
- [ExceptionTranslationFilter], que transforma las denegaciones de acceso en respuestas HTTP: punto de entrada para un usuario anónimo, error 403 para un usuario autenticado (ejemplo 26);
- [AuthorizationFilter], el último, que aplica las reglas de [authorizeHttpRequests].
El archivo [controllers/AuthController.java]:
| package example25.controllers;
import java.util.Optional;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import example25.auth.AuthService;
import example25.auth.UsersService.User;
import jakarta.servlet.http.HttpServletResponse;
@Controller
public class AuthController {
private final AuthService auth;
public AuthController(AuthService auth) {
this.auth = auth;
}
@GetMapping("/")
public String home() {
return "redirect:/profile";
}
@GetMapping("/login")
public String form() {
return "auth/login";
}
@PostMapping("/login")
public String login(@RequestParam(required = false) String login,
@RequestParam(required = false) String password, HttpServletResponse response, Model model) {
Optional<User> user = auth.validate(login, password);
if (user.isEmpty()) {
// un mensaje deliberadamente vago: no indicamos si el error es el login o la contraseña
model.addAttribute("error", "Incorrect login or password.");
model.addAttribute("login", login);
return "auth/login";
}
// el token, en una cookie
response.addHeader(HttpHeaders.SET_COOKIE, auth.cookie(auth.createToken(user.get())).toString());
return "redirect:/profile";
}
}
|
Analicemos este código:
- líneas 35-44: el inicio de sesión. Los parámetros son opcionales ([required = false]): un parámetro ausente toma por defecto el valor [null], y [AuthService.validate] lo rechaza. Si el inicio de sesión falla, el formulario se vuelve a mostrar con un mensaje deliberadamente vago: indicar "este nombre de usuario no existe" ayudaría a un atacante a encontrar nombres de usuario válidos;
- línea 46: si tiene éxito, la cookie se agrega a la respuesta como un encabezado [Set-Cookie], antes de la redirección al perfil;
- No hay ninguna acción [/logout]: el cierre de sesión lo maneja el filtro [LogoutFilter], incluso antes de que la solicitud llegue a [Spring MVC].
El archivo [controllers/ProfileController.java]:
| package example25.controllers;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
// reservado a los usuarios autenticados: vea SecurityConfig (anyRequest().authenticated())
@Controller
public class ProfileController {
// Authentication: el usuario autenticado por el token;
// @AuthenticationPrincipal Jwt: el token mismo, ya verificado
@GetMapping("/profile")
public String profile(Authentication user, @AuthenticationPrincipal Jwt token, Model model) {
model.addAttribute("name", user.getName());
model.addAttribute("admin", user.getAuthorities().stream()
.anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN")));
model.addAttribute("claims", token.getClaims());
return "profile/profile";
}
}
|
- Línea 10: no hay ninguna anotación de seguridad en el controlador: la regla [anyRequest().authenticated()] de [SecurityConfig] ya protege [/profile];
- Línea 17: una acción puede recibir al usuario autenticado como parámetro, de tipo [Authentication], almacenado en el contexto de seguridad por el filtro del resource server. La anotación [@AuthenticationPrincipal] proporciona acceso al principal de este usuario: en la autenticación mediante JWT, es el propio token (de tipo [Jwt]), que ya ha sido verificado;
- línea 18: el nombre del usuario, el claim [name] (véase [setPrincipalClaimName]);
- Líneas 19-20: ¿es el usuario un administrador? Verificamos la autoridad [ROLE_ADMIN] entre las autoridades del usuario;
- línea 21: los claims del token, en forma de diccionario ([Map<String, Object>]).
El archivo [templates/profile/profile.html]:
| <!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
<h1 class="h3" th:text="|Hello ${name}|">Hello</h1>
<p>Your role: <b th:text="${admin} ? 'administrator' : 'user'">user</b>.</p>
<p>The content of your token:</p>
<table class="table table-sm w-auto">
<!--un bucle sobre un diccionario: cada elemento tiene una clave y un valor-->
<tr th:each="claim : ${claims}"><td><code th:text="${claim.key}">sub</code></td><td th:text="${claim.value}">marie</td></tr>
</table>
<!--cierre de sesión: un formulario POST reducido a su botón-->
<form method="post" action="/logout">
<button class="btn btn-outline-secondary" type="submit">Log out</button>
</form>
</main>
</body>
</html>
|
- línea 10: [th:each] también itera sobre un diccionario: cada elemento tiene una clave ([claim.key]) y un valor ([claim.value]);
- Líneas 13-15: el cierre de sesión, mediante un formulario POST reducido a su botón.
El archivo [templates/auth/login.html]:
| <!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
<h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" th:value="${login}" required>
</div>
<div class="mb-3">
<label class="form-label" for="password">Password</label>
<input class="form-control" type="password" id="password" name="password" required>
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
<div class="alert alert-danger mt-3" th:if="${error != null}" th:text="${error}">error</div>
<p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
</main>
</body>
</html>
|
- línea 9: el nombre de usuario ingresado se vuelve a mostrar tras un inicio de sesión fallido; la contraseña nunca se vuelve a mostrar;
- línea 17: el mensaje de error, si lo hay.
La plantilla [templates/layout.html] y la clase [config/WebConfig.java], que sirven los archivos de [Bootstrap] bajo la URL [/bootstrap/...], son las mismas que las de los ejemplos anteriores (véanse el ejemplo 15 y el capítulo 1).
8.1.1. Ejecución
Sin cookie, la página protegida redirige a la página de inicio de sesión:
| curl -i http://localhost:5000/profile
|
| HTTP/1.1 302
Location: http://localhost:5000/login
Content-Length: 0
|
([Tomcat] no incluye el texto [Found], que suele acompañar al código 302: es opcional).

Una contraseña incorrecta:

Inicio de sesión exitoso, visto por [curl]:
| curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
|
| HTTP/1.1 302
Set-Cookie: token=eyJraWQiOiJLQzBjVllOZXdUWWFTY1FWM21EV1ZEbFQ0bDZWYmFfUTNSNjB6cmNtWmQ0IiwiYWxnIjoiSFMyNTYifQ.eyJuYW1lIjoiTWFyaWUgUMOpbGlzc2llciIsInN1YiI6Im1hcmllIiwicm9sZSI6IlVTRVIiLCJleHAiOjE3OTAzNTgzNTYsImlhdCI6MTc5MDM1NDc1Nn0.ZsCOrkYPuZFYu2xPtIx3JGpKBQCOJP9dqF8fzkwpLmo; Path=/; Max-Age=3600; Expires=Fri, 25 Sep 2026 17:45:56 GMT; HttpOnly; SameSite=Lax
Location: http://localhost:5000/profile
Content-Length: 0
|
El token consta de tres partes separadas por puntos: un encabezado, el contenido y la firma. Las dos primeras simplemente se codifican como [base64url]. El encabezado decodificado:
| {"kid":"KC0cVYNewTYaScQV3mDWVDlT4l6Vba_Q3R60zrcmZd4","alg":"HS256"}
|
Contiene el algoritmo de firma ([alg]) y un identificador de clave ([kid], [key id]): cuando un servidor usa varias claves, el [kid] le indica qué clave firmó el token. [NimbusJwtEncoder] lo calcula por sí mismo a partir de la clave (es la huella SHA-256 de la clave, según el estándar [JWK Thumbprint]): no revela nada sobre la clave. El contenido decodificado:
| {
"name": "Marie Pélissier",
"sub": "marie",
"role": "USER",
"exp": 1790358356,
"iat": 1790354756
}
|
Encontramos los claims generados por [createToken]. Las fechas [exp] y [iat] se escriben en segundos desde el 1 de enero de 1970. El token no está cifrado: no se incluye en él nada secreto. En el navegador, en la URL http://localhost:5000/profile:

En la página, las fechas [exp] y [iat] se muestran en formato ISO 8601: el decodificador las convirtió en objetos [Instant] (un instante en tiempo universal, de ahí la [Z] final). Vemos que el token es válido durante una hora.
Ahora intentemos modificar el token para asignarnos el rol ADMIN: decodificamos el contenido, reemplazamos [USER] por [ADMIN] y lo volvemos a codificar... pero no podemos recalcular la firma sin la clave secreta:
| curl -i -b "token=eyJraWQiOi...(modified content)...(old signature)" http://localhost:5000/profile
|
| HTTP/1.1 302
Set-Cookie: token=; Path=/; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT
Location: http://localhost:5000/login
Content-Length: 0
|
La firma ya no coincide con el contenido: el decodificador rechaza el token, el filtro llama al punto de entrada, que borra la cookie y redirige a la página de inicio de sesión. Cierre de sesión:
| curl -i -b cookies.txt -X POST http://localhost:5000/logout
|
| HTTP/1.1 302
Set-Cookie: token=; Expires=Thu, 01 Jan 1970 00:00:10 GMT; Path=/
Location: http://localhost:5000/login
Content-Length: 0
|
El filtro [LogoutFilter] borra la cookie restableciéndola, vacía, con una fecha de expiración vencida. Observe que, como la protección [CSRF] está deshabilitada, [Spring Security] también acepta el cierre de sesión mediante un GET ([curl -i http://localhost:5000/logout] devuelve la misma respuesta): aquí es inofensivo (en el peor de los casos, un enlace malicioso cierra la sesión del usuario), pero nuestras páginas siempre cierran la sesión mediante un POST.
8.2. Ejemplo 26: Roles
El ejemplo 26 se basa en el ejemplo 25 y agrega una página reservada para el rol ADMIN. El rol ya es una autoridad del usuario autenticado ([ROLE_ADMIN]): solo falta exigirlo. El archivo [controllers/AdminController.java]:
| package example26.controllers;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
// todo el controlador está reservado al rol ADMIN: hay que estar autenticado Y
// tener el rol ADMIN (el claim "role" del token, vea SecurityConfig)
@Controller
@PreAuthorize("hasRole('ADMIN')")
public class AdminController {
@GetMapping("/admin")
public String admin(Authentication user, Model model) {
model.addAttribute("name", user.getName());
return "admin/admin";
}
}
|
- línea 12: la anotación [@PreAuthorize] establece una condición, que se verifica antes de llamar a cada acción del controlador. La condición es una expresión en el lenguaje [SpEL] ([Spring Expression Language]): [hasRole('ADMIN')] es verdadera si el usuario tiene la autoridad [ROLE_ADMIN] (el prefijo [ROLE_] lo agrega [hasRole]). A un usuario anónimo se lo redirige primero a la página de inicio de sesión (punto de entrada); un usuario autenticado sin este rol recibe una respuesta 403, "Access Denied". [hasAnyRole('ADMIN', 'DOCTOR')] aceptaría cualquiera de estos roles.
Para que [@PreAuthorize] se tenga en cuenta, la clase [SecurityConfig] tiene una anotación adicional:
| // la configuración de Spring Security.
// @EnableMethodSecurity: habilita las anotaciones @PreAuthorize de los controladores
@Configuration
@EnableMethodSecurity
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {
|
- Línea 4: [@EnableMethodSecurity] habilita la seguridad de métodos. [Spring] envuelve entonces cada bean cuyo método lleva [@PreAuthorize] en un proxy: un objeto intermediario que recibe las llamadas en nombre del bean, verifica la condición y luego llama al método real o lanza una excepción [AccessDeniedException]. Volveremos sobre este mecanismo de proxy en el contexto de las transacciones en el próximo capítulo.
La cadena de filtros ha cambiado en dos lugares:
| .oauth2ResourceServer(jwt -> jwt
.bearerTokenResolver(tokenFromCookie())
.authenticationEntryPoint(toLogin())
.accessDeniedHandler(accessDenied())
.jwt(config -> config.jwtAuthenticationConverter(converter())))
// 3. página protegida solicitada sin token: se redirige a la página de inicio de sesión;
// rol insuficiente: una respuesta 403, convertida en página por ErrorPageController
.exceptionHandling(errors -> errors.authenticationEntryPoint(toLogin())
.accessDeniedHandler(accessDenied()))
|
- líneas 4 y 9: el manejador de denegación de acceso ([access denied handler]). La excepción lanzada por [@PreAuthorize] se propaga, a través de [Spring MVC], hasta el filtro [ExceptionTranslationFilter], que se la pasa a este manejador. El manejador del resource server devolvería una respuesta 403 sin contenido, con un encabezado [WWW-Authenticate] destinado a un cliente [JavaScript]. Como con el punto de entrada, esto se reemplaza en dos lugares.
El propio manejador, al final del archivo:
| // rol insuficiente: una respuesta de error 403, que el servidor reenvía a /error
private static AccessDeniedHandler accessDenied() {
return (request, response, exception) -> response.sendError(HttpServletResponse.SC_FORBIDDEN);
}
|
- líneas 2-4: nuestro manejador simplemente usa [sendError(403)]. El servidor [Tomcat] reenvía entonces la solicitud a la URL [/error] (véase el ejemplo 24), es decir, al manejador de errores. Por eso [/error] aparece entre las URL públicas: la solicitud reenviada también pasa por la cadena de filtros.
El archivo [controllers/ErrorPageController.java]:
| package example26.controllers;
import org.springframework.boot.webmvc.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
// la página de las respuestas de error (403, 404...): vea el ejemplo 24
@Controller
public class ErrorPageController implements ErrorController {
@RequestMapping("/error")
public String error(HttpServletRequest request, HttpServletResponse response, Model model) {
Object code = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
int status = code instanceof Integer c ? c : 500;
response.setStatus(status);
model.addAttribute("code", status);
return "error";
}
}
|
- líneas 14-16: el controlador de la página de error, como en el ejemplo 24: implementa la interfaz [ErrorController] de [Spring Boot], con lo que reemplaza la página de error predeterminada;
- Líneas 18-21: el código de estado de la respuesta de error (403, 404, etc.) es un atributo de la solicitud; se copia en la respuesta y en la plantilla de la vista.
La vista [templates/error.html]:
| <!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
<div class="alert alert-danger">
<h1 class="h4" th:text="|Error ${code}|">Error 403</h1>
<p class="mb-0" th:text="${code == 403} ? 'Access denied: this page is reserved for administrators.' : 'An error occurred.'">message</p>
</div>
<p><a href="/profile">Back to the profile</a></p>
</main>
</body>
</html>
|
- línea 7: un mensaje específico para el error 403 y un mensaje genérico para los demás.
Por último, la página de perfil tiene un enlace más, a [/admin]. La usuaria [marie] (rol USER) intenta abrir la página de administración desde su perfil:


El mismo intento de [admin]:

Con [curl], vemos un error 403:
| curl -i -c cookies.txt -d "login=marie&password=marie" http://localhost:5000/login
curl -i -b cookies.txt http://localhost:5000/admin
|
| HTTP/1.1 403
Content-Type: text/html;charset=UTF-8
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Authentication</title>
<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
<div class="container py-3" style="max-width: 34rem">
<main>
<div class="alert alert-danger">
<h1 class="h4">Error 403</h1>
<p class="mb-0">Access denied: this page is reserved for administrators.</p>
</div>
<p><a href="/profile">Back to the profile</a></p>
</main>
</div>
</body>
</html>
|
El caso de estudio tiene tres roles (ADMIN, DOCTOR, USER) y utiliza exactamente estos mecanismos: la regla [anyRequest().authenticated()] protege todas las páginas excepto las de inicio de sesión y creación de cuenta; [@PreAuthorize("hasRole('ADMIN')")] restringe al administrador el acceso a la gestión de médicos y clientes; [@PreAuthorize("hasRole('USER')")] restringe a los pacientes el acceso al área de pacientes. Allí se muestra la página 403.
8.3. Ejemplo 27: CAPTCHA y límites de intentos
Una página de inicio de sesión atrae a los bots: programas que prueban miles de combinaciones distintas de nombre de usuario y contraseña. Dos salvaguardas complementarias:
- un CAPTCHA: una imagen de caracteres distorsionados que un humano puede leer con facilidad pero que un bot simple no puede descifrar;
- un límite de intentos: tras unos pocos intentos fallidos, la dirección IP se bloquea durante un tiempo.
El ejemplo 27 agrega estas dos salvaguardas al ejemplo 25. El archivo [auth/CaptchaService.java]:
| package example27.auth;
import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.stereotype.Service;
// singleton: los captchas pendientes se conservan en memoria en el servidor
@Service
public class CaptchaService {
// un captcha: su identificador y su imagen (SVG)
public record Captcha(String id, String svg) {
}
// la respuesta esperada y su fecha de expiración
private record Expected(String text, Instant expires) {
}
private static final Duration LIFETIME = Duration.ofMinutes(10);
// identificador -> respuesta esperada.
// ConcurrentHashMap: un diccionario utilizable por varias solicitudes simultáneas
private final Map<String, Expected> pending = new ConcurrentHashMap<>();
public Captcha generate() {
String text = CaptchaDrawing.randomText(5);
String id = UUID.randomUUID().toString(); // un identificador aleatorio, imposible de adivinar
pending.put(id, new Expected(text, Instant.now().plus(LIFETIME)));
return new Captcha(id, CaptchaDrawing.svg(text));
}
// el captcha se CONSUME en todos los casos: una imagen se usa una sola vez
public boolean check(String id, String input) {
Expected expected = id == null ? null : pending.remove(id);
return expected != null && input != null
&& expected.expires().isAfter(Instant.now())
&& expected.text().equalsIgnoreCase(input.trim());
}
}
|
Comentemos este código:
- líneas 11-13: un servicio es un bean singleton (véase el ejemplo 06): una única instancia, compartida por todas las solicitudes. Por lo tanto, los CAPTCHA pendientes se mantienen en la memoria del servidor;
- líneas 16-21: dos records: el CAPTCHA enviado a la página (identificador e imagen) y la respuesta esperada, almacenada por el servidor;
- línea 27: las respuestas esperadas se almacenan bajo un identificador aleatorio. La página contiene solo la imagen y el identificador: la respuesta nunca sale del servidor. El servicio es utilizado por solicitudes concurrentes, ejecutadas por diferentes hilos: [ConcurrentHashMap] es un diccionario diseñado para este fin;
- líneas 29-34: una cadena de cinco caracteres generada al azar, almacenada durante diez minutos y renderizada como una imagen. [UUID.randomUUID()] genera un identificador aleatorio de 128 bits imposible de adivinar;
- líneas 37-42: el proceso de verificación consume el CAPTCHA ([remove] lo elimina del diccionario y devuelve el valor eliminado): una imagen se usa una sola vez; un bot no puede reutilizar una solución que ya encontró. Un CAPTCHA vencido se rechaza; las mayúsculas no importan ([equalsIgnoreCase]).
La imagen la maneja la clase [auth/CaptchaDrawing.java], tomada del caso de estudio. No se requiere ninguna biblioteca: la imagen está en formato [SVG] ([Scalable Vector Graphics]), un formato de imagen vectorial compuesto de texto (XML), que el navegador puede mostrar. El comienzo del archivo:
| // el dibujo de un captcha: una imagen SVG (texto XML) construida a mano
final class CaptchaDrawing {
private static final int WIDTH = 150;
private static final int HEIGHT = 50;
// SecureRandom: un generador de números aleatorios "criptográfico",
// impredecible (a diferencia de Random, cuya secuencia podría adivinarse)
private static final SecureRandom RANDOM = new SecureRandom();
// La "fuente": cada carácter es una lista de trazos, cada trazo una
// secuencia de puntos (x, y) en una cuadrícula de 4 x 6 (y apuntando hacia abajo).
// Caracteres demasiado fáciles de confundir entre sí: excluidos (0 O, 1 I L).
private static final Map<Character, double[][]> FONT = new LinkedHashMap<>();
static {
|
- línea 2: una clase [final] (de la que no se puede heredar), sin la palabra clave [public]: solo es visible para las clases de su paquete, [example27.auth];
- línea 9: el número aleatorio lo genera [SecureRandom], un generador criptográfico: la secuencia de sus salidas es impredecible, incluso para quien conoce las salidas anteriores. No sucede lo mismo con [Random], cuya secuencia puede reconstruirse a partir de unos pocos valores generados: un bot podría entonces predecir los CAPTCHA siguientes;
- líneas 11-14: cada carácter se describe mediante una lista de trazos en una pequeña cuadrícula. Se excluyen los caracteres que se confunden fácilmente (0 y O, 1, I y L). El resto del archivo (no reproducido aquí) llena este diccionario en un bloque [static { ... }] que se ejecuta una vez cuando se carga la clase.
El dibujo de la imagen:
| static String svg(String text) {
StringBuilder svg = new StringBuilder();
svg.append("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"%d\" height=\"%d\" viewBox=\"0 0 %d %d\">"
.formatted(WIDTH, HEIGHT, WIDTH, HEIGHT));
svg.append("<rect width=\"100%\" height=\"100%\" fill=\"#f5f7fa\"/>");
// los caracteres: cada uno ampliado, inclinado, desplazado, y cada punto
// ligeramente movido al azar
double step = (WIDTH - 20) / (double) text.length();
for (int i = 0; i < text.length(); i++) {
double scale = random(4.6, 5.6); // tamaño de una unidad de la cuadrícula, en píxeles
double angle = random(-0.35, 0.35); // rotación, en radianes (aproximadamente ±20°)
double cx = 10 + step * (i + 0.5) + random(-3, 3); // centro del carácter
double cy = HEIGHT / 2.0 + random(-4, 4);
StringBuilder d = new StringBuilder();
for (double[] stroke : FONT.get(text.charAt(i))) {
for (int k = 0; k < stroke.length; k += 2) {
// punto de la cuadrícula, centrado en (2, 3), distorsionado, rotado, colocado
double x = (stroke[k] - 2 + random(-0.2, 0.2)) * scale;
double y = (stroke[k + 1] - 3 + random(-0.2, 0.2)) * scale;
double px = cx + x * Math.cos(angle) - y * Math.sin(angle);
double py = cy + x * Math.sin(angle) + y * Math.cos(angle);
d.append(k == 0 ? 'M' : 'L').append(number(px)).append(' ').append(number(py)).append(' ');
}
}
svg.append("<path d=\"%s\" fill=\"none\" stroke=\"%s\" stroke-width=\"%s\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>"
.formatted(d.toString().trim(), color(), number(random(2.2, 3))));
}
// 3 trazos de ruido: curvas que cruzan la imagen
for (int n = 0; n < 3; n++) {
svg.append("<path d=\"M%s %s C%s %s %s %s %s %s\" fill=\"none\" stroke=\"%s\" stroke-width=\"1.3\"/>"
.formatted(number(random(0, 20)), number(random(5, 45)),
number(random(30, 60)), number(random(0, 50)), number(random(90, 120)), number(random(0, 50)),
number(random(130, 150)), number(random(5, 45)), color()));
}
svg.append("</svg>");
return svg.toString();
}
// un número con punto decimal, sea cual sea el idioma del servidor
// (en francés, "%.1f" escribiría "12,5", ilegible para SVG)
private static String number(double value) {
return String.format(Locale.ROOT, "%.1f", value);
}
|
- Líneas 3-5: la imagen SVG es un elemento [<svg>] de 150 x 50 píxeles, sobre un fondo claro (un rectángulo [<rect>]). ["...".formatted(...)] reemplaza los [%d] y [%s] del texto por los valores dados, igual que [String.format];
- Líneas 9-28: cada carácter se convierte en un trazado [<path>]: una secuencia de puntos conectados por segmentos ([M]: ir al punto; [L]: dibujar un segmento hasta el punto). Cada carácter se agranda, se inclina y se desplaza al azar, y cada uno de sus puntos se mueve ligeramente: nunca hay dos imágenes idénticas del mismo texto;
- líneas 31-36: tres curvas de distorsión ([C]: una curva de Bézier) cruzan la imagen para confundir a un programa de reconocimiento de caracteres;
- líneas 43-45: los números se escriben con punto decimal independientemente del idioma del servidor ([Locale.ROOT]): en francés, [%.1f] escribiría una coma, que SVG no reconoce.
El archivo [auth/LimiterService.java]:
| package example27.auth;
import java.time.Duration;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
// singleton: cuenta los fallos de inicio de sesión de cada dirección IP
@Service
public class LimiterService {
private static final int MAX_FAILURES = 3;
private static final Duration BLOCK_DURATION = Duration.ofMinutes(1);
private static class Counter {
int failures;
Instant blockedUntil = Instant.MIN;
}
private final Map<String, Counter> counters = new HashMap<>();
// synchronized: varias solicitudes simultáneas, un solo acceso a la vez
// el número de segundos de bloqueo restantes (0: no bloqueado)
public synchronized long blockedSeconds(String ip) {
Counter c = counters.get(ip);
if (c == null) {
return 0;
}
Duration remaining = Duration.between(Instant.now(), c.blockedUntil);
return remaining.isNegative() || remaining.isZero() ? 0 : (remaining.toMillis() + 999) / 1000;
}
public synchronized void failure(String ip) {
Counter c = counters.computeIfAbsent(ip, key -> new Counter());
c.failures++;
if (c.failures >= MAX_FAILURES) {
c.blockedUntil = Instant.now().plus(BLOCK_DURATION);
c.failures = 0; // tras el bloqueo, se empieza de nuevo desde cero
}
}
public synchronized void success(String ip) {
counters.remove(ip);
}
}
|
- líneas 14-15: tres fallos bloquean la dirección IP durante un minuto;
- líneas 17-20: el contador de una dirección: número de fallos y fecha de fin del bloqueo ([Instant.MIN], un momento muy lejano en el pasado, al inicio);
- línea 22: el diccionario de contadores es compartido por todas las solicitudes. Es un simple [HashMap], que no admite el acceso concurrente: por eso cada método es [synchronized]. La palabra clave garantiza que un solo hilo a la vez ejecute uno de los métodos [synchronized] del objeto: no pueden producirse dos fallos simultáneos (véase [AtomicInteger], capítulo 6);
- líneas 27-34: el tiempo de bloqueo restante, redondeado hacia arriba al siguiente segundo;
- líneas 36-43: se cuenta un fallo; al tercer fallo, la dirección se bloquea. [computeIfAbsent] devuelve el contador de la dirección después de crearlo si no existía;
- líneas 45-47: un éxito borra el contador.
El archivo [controllers/AuthController.java]:
| package example27.controllers;
import java.util.Optional;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import example27.auth.AuthService;
import example27.auth.CaptchaService;
import example27.auth.LimiterService;
import example27.auth.UsersService.User;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@Controller
public class AuthController {
private final AuthService auth;
private final CaptchaService captchas;
private final LimiterService limiter;
public AuthController(AuthService auth, CaptchaService captchas, LimiterService limiter) {
this.auth = auth;
this.captchas = captchas;
this.limiter = limiter;
}
@GetMapping("/")
public String home() {
return "redirect:/profile";
}
@GetMapping("/login")
public String form(Model model) {
return loginPage(model, null, null);
}
@PostMapping("/login")
public String login(@RequestParam(required = false) String login,
@RequestParam(required = false) String password, @RequestParam(required = false) String captchaId,
@RequestParam(required = false) String captcha, HttpServletRequest request,
HttpServletResponse response, Model model) {
// la dirección IP del cliente
String ip = request.getRemoteAddr();
// 1. una dirección bloqueada ni siquiera es atendida
long seconds = limiter.blockedSeconds(ip);
if (seconds > 0) {
return loginPage(model, login, "Too many attempts: try again in " + seconds + " s.");
}
// 2. primero el captcha (barato), después la contraseña (bcrypt, costoso)
if (!captchas.check(captchaId, captcha)) {
limiter.failure(ip);
return loginPage(model, login, "The image code is incorrect.");
}
Optional<User> user = auth.validate(login, password);
if (user.isEmpty()) {
limiter.failure(ip);
return loginPage(model, login, "Incorrect login or password.");
}
limiter.success(ip);
response.addHeader(HttpHeaders.SET_COOKIE, auth.cookie(auth.createToken(user.get())).toString());
return "redirect:/profile";
}
// cada visualización del formulario construye un captcha NUEVO
private String loginPage(Model model, String login, String error) {
model.addAttribute("login", login);
model.addAttribute("error", error);
model.addAttribute("captcha", captchas.generate());
return "auth/login";
}
}
|
Comentemos este código:
- línea 48: la dirección IP del cliente, proporcionada por la conexión de red;
- líneas 51-54: a una dirección bloqueada ni siquiera se la escucha;
- líneas 56-59: primero se verifica el CAPTCHA y luego la contraseña (una operación [bcrypt] costosa en cómputo) solo si el CAPTCHA es correcto. Un CAPTCHA incorrecto cuenta como un fallo;
- líneas 71-76: cada vez que se muestra el formulario, se genera un nuevo CAPTCHA y se coloca en la plantilla de la vista. Esto también se aplica a la primera visualización (líneas 37-40).
El archivo [templates/auth/login.html]:
| <!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
<h1 class="h3">Login</h1>
<form method="post" action="/login">
<div class="mb-2">
<label class="form-label" for="login">Login</label>
<input class="form-control" id="login" name="login" th:value="${login}" required>
</div>
<div class="mb-2">
<label class="form-label" for="password">Password</label>
<input class="form-control" type="password" id="password" name="password" required>
</div>
<div class="mb-3">
<label class="form-label" for="captcha">Copy the code of the image</label>
<!--la imagen SVG, construida por el servidor: insertada sin escapar-->
<div class="mb-1" th:utext="${captcha.svg}">image</div>
<!--el identificador del captcha viaja en un campo oculto; la respuesta permanece en el servidor-->
<input type="hidden" name="captchaId" th:value="${captcha.id}">
<input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
</div>
<button class="btn btn-primary" type="submit">Log in</button>
</form>
<div class="alert alert-danger mt-3" th:if="${error != null}" th:text="${error}">error</div>
<p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
</main>
</body>
</html>
|
- línea 18: la imagen SVG es texto (XML): se inserta en la página tal cual. [th:utext] ([unescaped text]) inserta el texto sin escapar: los caracteres [<] y [>] siguen siendo etiquetas (con [th:text], se convertirían en [<] y [>], y la página mostraría el código de la imagen). [th:utext] es válido aquí: es HTML generado por el servidor, no entrada del usuario;
- línea 20: el identificador del CAPTCHA se pasa en un campo oculto; la respuesta, en cambio, permanece en el servidor;
- línea 21: [autocomplete="off"]: el navegador no sugiere entradas anteriores, que son irrelevantes para un CAPTCHA.
El archivo [config/SecurityConfig.java] es exactamente el mismo que en el ejemplo 25 (y no el del ejemplo 26: aquí no hay ni [@EnableMethodSecurity] ni un manejador de denegación de acceso, ya que ninguna página está reservada para un rol específico). En particular, la regla de acceso [/login] permanece sin cambios: la página de inicio de sesión sigue siendo pública y el CAPTCHA lo verifica el controlador, no [Spring Security].
La página de inicio de sesión, en la URL http://localhost:5000/login:

Un CAPTCHA ingresado incorrectamente:

Se ha generado un nuevo CAPTCHA. Volver a enviar un CAPTCHA que ya se usó, incluso si se ingresa correctamente, produce el mismo mensaje: la respuesta se eliminó del diccionario durante su verificación inicial. Después de tres intentos fallidos, incluso la contraseña correcta, junto con el CAPTCHA correcto, es rechazada durante un minuto:

El caso de estudio aplica estas dos medidas de seguridad a su página de inicio de sesión y al proceso de creación de cuentas, con umbrales ajustables en el archivo [application.properties] (propiedades [rdvmedecins.protection.*]).