Capítulo 5: Seguridad Avanzada - Módulos 11 a 18

Objetivos

• Dominar Spring Security en profundidad
• Implementar una seguridad robusta paso a paso
• Comprender cada componente de la cadena de seguridad

---

Recurso Principal

Anexos Security

Este capítulo se basa en los annexes-security-1 del repositorio, una excelente guía paso a paso:

** Carpeta annexes-security-1**

Módulos 11 a 18: Un proyecto completo de seguridad Spring Boot.

---

Plan de los Módulos de Seguridad

Módulo	Título	Contenido
11	Introducción a Spring Security	Conceptos básicos, arquitectura
12	Configuración inicial	SecurityFilterChain, HttpSecurity
13	Autenticación	UserDetails, UserDetailsService
14	Codificación de contraseñas	BCryptPasswordEncoder
15	JWT - Teoría	Estructura, claims, firma
16	JWT - Implementación	JwtService, generación, validación
17	Filtros personalizados	JwtAuthenticationFilter
18	Autorización	Roles, @PreAuthorize, seguridad de métodos

---

Módulo 11: Introducción a Spring Security

¿Qué es Spring Security?

Spring Security es el framework estándar de seguridad para aplicaciones Spring. Proporciona:

• Autenticación: Verificar la identidad del usuario
• Autorización: Controlar el acceso a los recursos
• Protección contra ataques: CSRF, XSS, etc.

Arquitectura de Spring Security

┌───────────────────────────────────────────────────────────┐
│                    SecurityFilterChain                     │
│                                                           │
│   Request  ──►  Filter 1  ──►  Filter 2  ──►  ...  ──►  Controller
│                                                           │
│   Chaque filtre peut:                                     │
│   - Laisser passer la requête                            │
│   - Bloquer la requête (401/403)                         │
│   - Modifier la requête                                   │
└───────────────────────────────────────────────────────────┘

Dependencia Maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

---

Módulo 12: Configuración Inicial

SecurityConfig básica

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())  // Desactivar CSRF para API REST
            .authorizeHttpRequests(auth -> auth
                .anyRequest().permitAll()  // Permitir todo al principio
            )
            .build();
    }
}

Configuración progresiva

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(auth -> auth
            // Endpoints públicos
            .requestMatchers("/api/contact").permitAll()
            .requestMatchers("/api/auth/**").permitAll()
            .requestMatchers("/h2-console/**").permitAll()
            
            // Endpoints protegidos
            .requestMatchers("/api/admin/**").authenticated()
            
            // Todo lo demás
            .anyRequest().authenticated()
        )
        .headers(headers -> headers.frameOptions(f -> f.disable())) // Para la consola H2
        .build();
}

---

Módulo 13: Autenticación

Entidad User

@Entity
@Table(name = "users")
public class User implements UserDetails {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true)
    private String email;
    
    private String password;
    
    @Enumerated(EnumType.STRING)
    private Role role;
    
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(new SimpleGrantedAuthority("ROLE_" + role.name()));
    }
    
    @Override
    public String getUsername() {
        return email;
    }
    
    @Override
    public boolean isAccountNonExpired() { return true; }
    
    @Override
    public boolean isAccountNonLocked() { return true; }
    
    @Override
    public boolean isCredentialsNonExpired() { return true; }
    
    @Override
    public boolean isEnabled() { return true; }
}

UserDetailsService

@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {
    
    private final UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        return userRepository.findByEmail(email)
            .orElseThrow(() -> new UsernameNotFoundException("Usuario no encontrado: " + email));
    }
}

Configuración de AuthenticationProvider

@Configuration
public class SecurityConfig {
    
    @Bean
    public AuthenticationProvider authenticationProvider(
            UserDetailsService userDetailsService,
            PasswordEncoder passwordEncoder) {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setUserDetailsService(userDetailsService);
        provider.setPasswordEncoder(passwordEncoder);
        return provider;
    }
    
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) 
            throws Exception {
        return config.getAuthenticationManager();
    }
}

---

Módulo 14: Codificación de Contraseñas

BCryptPasswordEncoder

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

Uso durante el registro

@Service
@RequiredArgsConstructor
public class AuthService {
    
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    
    public User register(RegisterRequest request) {
        User user = new User();
        user.setEmail(request.getEmail());
        user.setPassword(passwordEncoder.encode(request.getPassword())); // ¡Codificación!
        user.setRole(Role.USER);
        return userRepository.save(user);
    }
}

Verificación durante el inicio de sesión

public String login(LoginRequest request) {
    // El AuthenticationManager gestiona automáticamente la verificación de la contraseña
    Authentication authentication = authenticationManager.authenticate(
        new UsernamePasswordAuthenticationToken(
            request.getEmail(),
            request.getPassword()
        )
    );
    
    // Si llegamos aquí, la autenticación fue exitosa
    User user = (User) authentication.getPrincipal();
    return jwtService.generateToken(user);
}

---

Módulo 15: JWT - Teoría

Estructura de un JWT

Un JWT (JSON Web Token) está compuesto por tres partes separadas por puntos:

xxxxx.yyyyy.zzzzz
  │      │     │
  │      │     └── Firma
  │      └── Payload (Claims)
  └── Header

Header

{
  "alg": "HS256",
  "typ": "JWT"
}

Payload (Claims)

{
  "sub": "user@example.com",    // Subject (identificador)
  "iat": 1609459200,            // Issued At (fecha de creación)
  "exp": 1609545600,            // Expiración
  "roles": ["USER"]             // Claims personalizados
}

Firma

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret_key
)

---

Módulo 16: JWT - Implementación

Dependencia

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.12.3</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.12.3</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.12.3</version>
    <scope>runtime</scope>
</dependency>

JwtService

@Service
public class JwtService {
    
    @Value("${jwt.secret}")
    private String secretKey;
    
    @Value("${jwt.expiration}")
    private long expiration;  // En milisegundos
    
    // Generar un token
    public String generateToken(UserDetails userDetails) {
        return Jwts.builder()
            .subject(userDetails.getUsername())
            .claim("roles", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .toList())
            .issuedAt(new Date())
            .expiration(new Date(System.currentTimeMillis() + expiration))
            .signWith(getSigningKey())
            .compact();
    }
    
    // Extraer el username
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    
    // Validar el token
    public boolean isTokenValid(String token, UserDetails userDetails) {
        String username = extractUsername(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }
    
    private boolean isTokenExpired(String token) {
        return extractClaim(token, Claims::getExpiration).before(new Date());
    }
    
    private <T> T extractClaim(String token, Function<Claims, T> resolver) {
        Claims claims = Jwts.parser()
            .verifyWith(getSigningKey())
            .build()
            .parseSignedClaims(token)
            .getPayload();
        return resolver.apply(claims);
    }
    
    private SecretKey getSigningKey() {
        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        return Keys.hmacShaKeyFor(keyBytes);
    }
}

Configuración application.yml

jwt:
  secret: "votre-cle-secrete-tres-longue-au-moins-256-bits-encodee-en-base64"
  expiration: 86400000  # 24 horas en milisegundos

---

Módulo 17: Filtros Personalizados

JwtAuthenticationFilter

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    private final JwtService jwtService;
    private final UserDetailsService userDetailsService;
    
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        
        // 1. Recuperar el header Authorization
        String authHeader = request.getHeader("Authorization");
        
        // 2. Verificar si el header está presente y comienza con "Bearer "
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }
        
        // 3. Extraer el token
        String token = authHeader.substring(7);
        String username = jwtService.extractUsername(token);
        
        // 4. Si se encuentra username y aún no está autenticado
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            
            // 5. Cargar el usuario
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            
            // 6. Validar el token
            if (jwtService.isTokenValid(token, userDetails)) {
                
                // 7. Crear la autenticación
                UsernamePasswordAuthenticationToken authToken = 
                    new UsernamePasswordAuthenticationToken(
                        userDetails,
                        null,
                        userDetails.getAuthorities()
                    );
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                
                // 8. Colocar en el SecurityContext
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        
        // 9. Continuar la cadena de filtros
        filterChain.doFilter(request, response);
    }
}

Integración en SecurityConfig

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/contact").permitAll()
            .requestMatchers("/api/auth/**").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .sessionManagement(session -> 
            session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        )
        .authenticationProvider(authenticationProvider)
        // Añadir nuestro filtro ANTES de UsernamePasswordAuthenticationFilter
        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
        .build();
}

---

Módulo 18: Autorización

Anotaciones de Seguridad

@Configuration
@EnableMethodSecurity  // Activa @PreAuthorize, @PostAuthorize, etc.
public class SecurityConfig {
    // ...
}

@PreAuthorize

@RestController
@RequestMapping("/api/admin")
public class AdminController {
    
    // Accesible solo para ADMIN
    @GetMapping("/leads")
    @PreAuthorize("hasRole('ADMIN')")
    public List<LeadDto> getAllLeads() {
        return leadService.getAllLeads();
    }
    
    // Accesible para ADMIN y MANAGER
    @GetMapping("/leads/stats")
    @PreAuthorize("hasAnyRole('ADMIN', 'MANAGER')")
    public StatsDto getStats() {
        return leadService.getStats();
    }
    
    // Verificación dinámica
    @GetMapping("/users/{id}")
    @PreAuthorize("#id == principal.id or hasRole('ADMIN')")
    public UserDto getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
}

@PostAuthorize

@GetMapping("/{id}")
@PostAuthorize("returnObject.email == principal.username or hasRole('ADMIN')")
public LeadDto getLead(@PathVariable Long id) {
    return leadService.getLead(id);
}

Seguridad a nivel de Servicio

@Service
public class LeadService {
    
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteLead(Long id) {
        leadRepository.deleteById(id);
    }
    
    @PreAuthorize("isAuthenticated()")
    public List<LeadDto> getMyLeads() {
        // Recuperar el usuario autenticado
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String email = auth.getName();
        return leadRepository.findByCreatedBy(email);
    }
}

---

Arquitectura Final Completa

┌─────────────────────────────────────────────────────────────────┐
│                         Client Request                          │
│                  Authorization: Bearer <token>                  │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                     SecurityFilterChain                          │
│                                                                 │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │ 1. CorsFilter                                             │  │
│  │    - Gère les requêtes cross-origin                       │  │
│  └───────────────────────────────────────────────────────────┘  │
│                                │                                 │
│                                ▼                                 │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │ 2. JwtAuthenticationFilter                                │  │
│  │    - Extrait le token du header                          │  │
│  │    - Valide le token                                     │  │
│  │    - Charge UserDetails                                  │  │
│  │    - Crée Authentication                                 │  │
│  │    - Met dans SecurityContext                            │  │
│  └───────────────────────────────────────────────────────────┘  │
│                                │                                 │
│                                ▼                                 │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │ 3. AuthorizationFilter                                    │  │
│  │    - Vérifie les autorisations                           │  │
│  │    - hasRole(), hasAuthority()                           │  │
│  │    - Retourne 403 si non autorisé                        │  │
│  └───────────────────────────────────────────────────────────┘  │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                         Controller                               │
│                   @PreAuthorize vérifié                         │
└─────────────────────────────────────────────────────────────────┘

---

Checklist de Dominio

Después de estudiar estos módulos, usted debería ser capaz de:

• Configurar SecurityFilterChain
• Implementar UserDetails y UserDetailsService
• Codificar contraseñas con BCrypt
• Generar y validar tokens JWT
• Crear un filtro de autenticación personalizado
• Utilizar @PreAuthorize para autorización
• Escribir pruebas de seguridad

---

Recurso Completo

Acceso Directo

Para el detalle completo de cada módulo con todos los ejemplos de código:

** Anexos Security - Módulos 11 a 18**

¡Es un excelente proyecto de seguridad para estudiar en profundidad!

---

¡Felicitaciones!

Ha completado el Módulo 16 sobre el proyecto e-contact-backend. Ahora usted ha:

• Configurado un entorno con GitHub Codespaces
• Dominado el troubleshooting de Spring Boot
• Integrado un frontend con el backend
• Profundizado en los conceptos de seguridad
• Comprendido Spring Security de principio a fin

---

⏭️ Próximos Pasos

1. Practicar: Clonar el repositorio y experimentar
2. Modificar: Añadir nuevas funcionalidades
3. Probar: Escribir sus propias pruebas de seguridad
4. Desplegar: Poner en producción en un proveedor cloud

---

Volver al índice del módulo | Volver al inicio