Spring Security esencial

Spring Security es el framework de seguridad estándar para aplicaciones basadas en Spring, proporcionando un sistema completo de autenticación y autorización que se integra perfectamente con el ecosistema Spring. Esta tecnología permite implementar medidas de seguridad robustas tanto en aplicaciones web tradicionales como en APIs REST modernas.

Fundamentos de la seguridad en aplicaciones web

La seguridad en aplicaciones web abarca múltiples aspectos críticos que deben ser considerados desde el diseño inicial. Spring Security aborda estos desafíos mediante un enfoque integral que incluye la gestión de identidades, control de acceso, protección contra ataques comunes y integración con estándares modernos de seguridad.

El framework se basa en el concepto de filtros de seguridad que interceptan las peticiones HTTP antes de que lleguen a los controladores de la aplicación. Esta arquitectura permite aplicar políticas de seguridad de forma transparente y configurable, sin necesidad de modificar la lógica de negocio existente.

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            );
        return http.build();
    }
}

Autenticación: verificación de identidad

La autenticación es el proceso mediante el cual se verifica la identidad de un usuario. Spring Security soporta múltiples mecanismos de autenticación, desde formularios web tradicionales hasta tokens JWT para APIs REST.

En aplicaciones web con Thymeleaf, la autenticación basada en formularios proporciona una experiencia de usuario familiar. El framework maneja automáticamente la generación de tokens CSRF, la validación de credenciales y la gestión de sesiones.

@Controller
public class LoginController {
    
    @GetMapping("/login")
    public String loginPage() {
        return "login";
    }
    
    @PostMapping("/register")
    public String registerUser(@ModelAttribute UserRegistrationDto dto) {
        userService.registerUser(dto);
        return "redirect:/login?registered";
    }
}

Para APIs REST, Spring Security ofrece soporte nativo para JSON Web Tokens (JWT), que permiten implementar autenticación stateless. Los JWT encapsulan información del usuario y claims de autorización en un token firmado digitalmente.

@Component
public class JwtTokenProvider {
    
    public String generateToken(Authentication authentication) {
        UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();
        Date expiryDate = new Date(System.currentTimeMillis() + jwtExpirationInMs);
        
        return Jwts.builder()
                .setSubject(userPrincipal.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, jwtSecret)
                .compact();
    }
}

Autorización: control de acceso granular

La autorización determina qué recursos puede acceder un usuario autenticado. Spring Security implementa un sistema de autorización basado en roles y permisos que puede aplicarse a nivel de URL, método o incluso datos específicos.

Las anotaciones de seguridad proporcionan una forma declarativa de aplicar reglas de autorización directamente en los métodos de servicio o controladores:

@RestController
@RequestMapping("/api/admin")
public class AdminController {
    
    @PreAuthorize("hasRole('ADMIN')")
    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    
    @PreAuthorize("hasAuthority('USER_DELETE')")
    @DeleteMapping("/users/{id}")
    public ResponseEntity<?> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.ok().build();
    }
}

OAuth 2.0 y OpenID Connect: estándares modernos

OAuth 2.0 es el estándar de facto para autorización en aplicaciones modernas, permitiendo que las aplicaciones accedan a recursos en nombre del usuario sin exponer credenciales. Spring Security proporciona soporte completo para OAuth 2.0 tanto como cliente como servidor de autorización.

La integración con proveedores externos como GitHub, Google o Facebook simplifica el proceso de registro y autenticación para los usuarios:

@Configuration
public class OAuth2Config {
    
    @Bean
    public ClientRegistrationRepository clientRegistrationRepository() {
        return new InMemoryClientRegistrationRepository(
            githubClientRegistration(),
            googleClientRegistration()
        );
    }
    
    private ClientRegistration githubClientRegistration() {
        return ClientRegistration.withRegistrationId("github")
                .clientId("your-client-id")
                .clientSecret("your-client-secret")
                .scope("read:user")
                .authorizationUri("https://github.com/login/oauth/authorize")
                .tokenUri("https://github.com/login/oauth/access_token")
                .userInfoUri("https://api.github.com/user")
                .build();
    }
}

OpenID Connect extiende OAuth 2.0 para proporcionar información de identidad del usuario, creando un protocolo completo para single sign-on (SSO) y gestión de identidades federadas.

Arquitectura de filtros y personalización

Spring Security utiliza una cadena de filtros que procesa cada petición HTTP. Esta arquitectura permite insertar filtros personalizados para implementar lógica de seguridad específica:

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String token = extractTokenFromRequest(request);
        
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication auth = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(auth);
        }
        
        filterChain.doFilter(request, response);
    }
}