Chapitre 5: Security Avancée - Modules 11 à 18

Objectifs

• Maîtriser Spring Security de manière approfondie
• Implémenter une sécurité robuste pas à pas
• Comprendre chaque composant de la chaîne de sécurité

---

Ressource Principale

Annexes Security

Ce chapitre est basé sur les annexes-security-1 du repository, un excellent guide pas à pas:

** Dossier annexes-security-1**

Modules 11 à 18: Un projet complet de sécurité Spring Boot.

---

Plan des Modules Security

Module	Titre	Contenu
11	Introduction à Spring Security	Concepts de base, architecture
12	Configuration initiale	SecurityFilterChain, HttpSecurity
13	Authentification	UserDetails, UserDetailsService
14	Encodage des mots de passe	BCryptPasswordEncoder
15	JWT - Théorie	Structure, claims, signature
16	JWT - Implémentation	JwtService, génération, validation
17	Filtres personnalisés	JwtAuthenticationFilter
18	Autorisation	Rôles, @PreAuthorize, méthode security

---

Module 11: Introduction à Spring Security

Qu'est-ce que Spring Security?

Spring Security est le framework de sécurité standard pour les applications Spring. Il fournit:

• Authentification: Vérifier l'identité de l'utilisateur
• Autorisation: Contrôler l'accès aux ressources
• Protection contre les attaques: CSRF, XSS, etc.

Architecture 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                                   │
└───────────────────────────────────────────────────────────┘

Dépendance Maven

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

---

Module 12: Configuration Initiale

SecurityConfig de base

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())  // Désactiver CSRF pour API REST
            .authorizeHttpRequests(auth -> auth
                .anyRequest().permitAll()  // Tout autoriser pour commencer
            )
            .build();
    }
}

Configuration progressive

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(auth -> auth
            // Endpoints publics
            .requestMatchers("/api/contact").permitAll()
            .requestMatchers("/api/auth/**").permitAll()
            .requestMatchers("/h2-console/**").permitAll()
            
            // Endpoints protégés
            .requestMatchers("/api/admin/**").authenticated()
            
            // Tout le reste
            .anyRequest().authenticated()
        )
        .headers(headers -> headers.frameOptions(f -> f.disable())) // Pour H2 console
        .build();
}

---

Module 13: Authentification

Entité 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("Utilisateur non trouvé: " + email));
    }
}

Configuration de l'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();
    }
}

---

Module 14: Encodage des Mots de Passe

BCryptPasswordEncoder

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

Utilisation lors de l'inscription

@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())); // Encodage!
        user.setRole(Role.USER);
        return userRepository.save(user);
    }
}

Vérification lors de la connexion

public String login(LoginRequest request) {
    // L'AuthenticationManager gère automatiquement la vérification du mot de passe
    Authentication authentication = authenticationManager.authenticate(
        new UsernamePasswordAuthenticationToken(
            request.getEmail(),
            request.getPassword()
        )
    );
    
    // Si on arrive ici, l'authentification a réussi
    User user = (User) authentication.getPrincipal();
    return jwtService.generateToken(user);
}

---

Module 15: JWT - Théorie

Structure d'un JWT

Un JWT (JSON Web Token) est composé de trois parties séparées par des points:

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

Header

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

Payload (Claims)

{
  "sub": "user@example.com",    // Subject (identifiant)
  "iat": 1609459200,            // Issued At (date de création)
  "exp": 1609545600,            // Expiration
  "roles": ["USER"]             // Claims personnalisés
}

Signature

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

---

Module 16: JWT - Implémentation

Dépendance

<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 millisecondes
    
    // Générer 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();
    }
    
    // Extraire le username
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    
    // Valider le 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);
    }
}

Configuration application.yml

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

---

Module 17: Filtres Personnalisés

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. Récupérer le header Authorization
        String authHeader = request.getHeader("Authorization");
        
        // 2. Vérifier si le header est présent et commence par "Bearer "
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }
        
        // 3. Extraire le token
        String token = authHeader.substring(7);
        String username = jwtService.extractUsername(token);
        
        // 4. Si username trouvé et pas encore authentifié
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            
            // 5. Charger l'utilisateur
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            
            // 6. Valider le token
            if (jwtService.isTokenValid(token, userDetails)) {
                
                // 7. Créer l'authentification
                UsernamePasswordAuthenticationToken authToken = 
                    new UsernamePasswordAuthenticationToken(
                        userDetails,
                        null,
                        userDetails.getAuthorities()
                    );
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                
                // 8. Mettre dans le SecurityContext
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        
        // 9. Continuer la chaîne de filtres
        filterChain.doFilter(request, response);
    }
}

Intégration dans 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)
        // Ajouter notre filtre AVANT UsernamePasswordAuthenticationFilter
        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
        .build();
}

---

Module 18: Autorisation

Annotations de Sécurité

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

@PreAuthorize

@RestController
@RequestMapping("/api/admin")
public class AdminController {
    
    // Accessible uniquement aux ADMIN
    @GetMapping("/leads")
    @PreAuthorize("hasRole('ADMIN')")
    public List<LeadDto> getAllLeads() {
        return leadService.getAllLeads();
    }
    
    // Accessible aux ADMIN et MANAGER
    @GetMapping("/leads/stats")
    @PreAuthorize("hasAnyRole('ADMIN', 'MANAGER')")
    public StatsDto getStats() {
        return leadService.getStats();
    }
    
    // Vérification dynamique
    @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);
}

Sécurité au niveau Service

@Service
public class LeadService {
    
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteLead(Long id) {
        leadRepository.deleteById(id);
    }
    
    @PreAuthorize("isAuthenticated()")
    public List<LeadDto> getMyLeads() {
        // Récupérer l'utilisateur connecté
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        String email = auth.getName();
        return leadRepository.findByCreatedBy(email);
    }
}

---

Architecture Finale Complète

┌─────────────────────────────────────────────────────────────────┐
│                         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 Maîtrise

Après avoir étudié ces modules, vous devriez être capable de:

• Configurer SecurityFilterChain
• Implémenter UserDetails et UserDetailsService
• Encoder les mots de passe avec BCrypt
• Générer et valider des tokens JWT
• Créer un filtre d'authentification personnalisé
• Utiliser @PreAuthorize pour l'autorisation
• Écrire des tests de sécurité

---

Ressource Complète

Accès Direct

Pour le détail complet de chaque module avec tous les exemples de code:

** Annexes Security - Modules 11 à 18**

C'est un excellent projet de sécurité à étudier en profondeur!

---

Félicitations!

Vous avez terminé le Module 16 sur le projet e-contact-backend. Vous avez maintenant:

• Configuré un environnement avec GitHub Codespaces
• Maîtrisé le troubleshooting Spring Boot
• Intégré un frontend au backend
• Approfondi les concepts de sécurité
• Compris Spring Security de A à Z

---

⏭️ Prochaines Étapes

1. Pratiquer: Cloner le repository et expérimenter
2. Modifier: Ajouter de nouvelles fonctionnalités
3. Tester: Écrire vos propres tests de sécurité
4. Déployer: Mettre en production sur un cloud provider

---

Retour à l'index du module | Retour à l'accueil