Seguridad Stateless con Spring Security 6 y JWT en Java 17/21

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
class SeguridadConfig {

    @Bean
    SecurityFilterChain api(HttpSecurity http) throws Exception {
        return http
            .securityMatcher("/api/**")
            .csrf(csrf -> csrf.disable())                         // token en cabecera, no en cookie
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers(HttpMethod.GET, "/api/tareas/**").hasAuthority("SCOPE_tareas:leer")
                .anyRequest().authenticated())                    // siempre al final
            .oauth2ResourceServer(o -> o.jwt(Customizer.withDefaults()))
            .exceptionHandling(e -> e
                .authenticationEntryPoint(new BearerTokenAuthenticationEntryPoint())   // 401
                .accessDeniedHandler(new BearerTokenAccessDeniedHandler()))            // 403
            .build();
    }
}

# Opción 1: un proveedor de identidad (Keycloak, Auth0, Entra ID) publica sus claves
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://auth.acme.com/realms/taskflow
          # Spring descarga las claves públicas (JWKS) y valida firma, exp, nbf e iss

# Opción 2: tokens emitidos por la propia aplicación con clave pública RSA
#   jwt:
#     public-key-location: classpath:keys/public.pem

# Un token decodificado (la firma se omite):
# cabecera: {"alg":"RS256","typ":"JWT","kid":"2026-03"}
# carga:    {"sub":"ana","scope":"tareas:leer tareas:escribir",
#            "iat":1772359200,"exp":1772360100,"iss":"https://auth.acme.com/realms/taskflow"}

class ApiKeyFilter extends OncePerRequestFilter {
    private final Map<String, String> clavesPorServicio;   // en un caso real, hash de las claves

    ApiKeyFilter(Map<String, String> clavesPorServicio) { this.clavesPorServicio = clavesPorServicio; }

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws ServletException, IOException {
        String clave = req.getHeader("X-Api-Key");
        String servicio = clave == null ? null : clavesPorServicio.get(clave);

        if (servicio != null) {
            var auth = new UsernamePasswordAuthenticationToken(
                servicio, null, List.of(new SimpleGrantedAuthority("ROLE_SERVICIO")));
            SecurityContext ctx = SecurityContextHolder.createEmptyContext();
            ctx.setAuthentication(auth);
            SecurityContextHolder.setContext(ctx);         // visible para el resto de la petición
        }
        chain.doFilter(req, res);                          // sin clave: sigue anónimo y decidirá la autorización
    }
}

// Registro en la cadena:
// http.addFilterBefore(new ApiKeyFilter(claves), BearerTokenAuthenticationFilter.class);

@Service
class TareaService {

    @PreAuthorize("hasRole('ADMIN') or @permisos.esResponsable(#id, authentication.name)")
    public TareaResponse editar(long id, EditarTareaRequest req) { /* ... */ return null; }

    @PreAuthorize("hasAuthority('SCOPE_tareas:leer')")
    @PostAuthorize("returnObject.publica() or returnObject.responsable() == authentication.name")
    public TareaResponse obtener(long id) { /* ... */ return null; }
}

@Component("permisos")
class Permisos {
    private final TareaRepository repo;
    Permisos(TareaRepository repo) { this.repo = repo; }

    public boolean esResponsable(long tareaId, String usuario) {
        return repo.findResponsable(tareaId).map(usuario::equals).orElse(false);
    }
}

@Bean
PasswordEncoder passwordEncoder() {
    return PasswordEncoderFactories.createDelegatingPasswordEncoder();   // {bcrypt} por defecto
}

@Service
class RegistroService {
    private final PasswordEncoder encoder;
    private final UsuarioRepository repo;

    RegistroService(PasswordEncoder encoder, UsuarioRepository repo) {
        this.encoder = encoder;
        this.repo = repo;
    }

    public void registrar(String email, String contrasena) {
        String hash = encoder.encode(contrasena);
        // {bcrypt}$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy
        //          |  |  |-- 22 caracteres de sal + 31 de hash
        //          |  coste 10 (2^10 rondas)
        //          versión del algoritmo
        repo.save(new Usuario(email, hash));
    }

    public boolean credencialesValidas(String email, String contrasena) {
        return repo.findByEmail(email)
            .map(u -> encoder.matches(contrasena, u.hash()))   // nunca compares hashes con equals
            .orElse(false);
    }
}