Sécurisation avancée des API REST avec Spring Security 6 et JWT dans Spring Boot 3.x

Le développement d'applications modernes repose de plus en plus sur des architectures basées sur des microservices et des API REST. Dans ce contexte, la sécurité des API est primordiale pour protéger les données sensibles et garantir l'intégrité des systèmes. La maîtrise des mécanismes de sécurisation est donc une compétence indispensable pour tout développeur.

Cet article explore les stratégies de sécurisation avancée des API REST en s'appuyant sur les dernières versions des technologies phares de l'écosystème Java : Spring Security 6 et Spring Boot 3.x. Il sera détaillé comment intégrer l'authentification basée sur les JSON Web Tokens (JWT) pour offrir une approche robuste, stateless et scalable. Laty Gueye Samba, Développeur Full Stack Java Spring Boot + Angular basé à Dakar, met régulièrement en œuvre ces techniques pour concevoir des applications sécurisées et performantes, adaptées aux exigences des projets modernes.

Le développeur Full Stack à Dakar, Laty Gueye Samba, spécialiste en Java Spring Boot et Angular, souligne l'importance d'une sécurité proactive et rigoureuse. L'objectif est de fournir une compréhension technique approfondie pour permettre aux développeurs de protéger efficacement leurs API REST contre les menaces courantes, tout en maintenant une excellente expérience utilisateur et une architecture logicielle flexible.

Comprendre Spring Security 6 et l'architecture JWT

Spring Security est le cadre de référence pour la sécurisation des applications Spring. Avec sa version 6, des améliorations significatives ont été apportées, notamment en termes de configuration et de modularité. Spring Security 6 s'intègre parfaitement avec Spring Boot 3.x, qui nécessite Java 17 minimum et adopte Jakarta EE pour la spécification des servlets.

L'authentification traditionnelle basée sur les sessions, bien que robuste, peut devenir un goulot d'étranglement pour les API REST distribuées et les architectures sans état (stateless). C'est là que les JSON Web Tokens (JWT) entrent en jeu. Un JWT est un jeton compact, sûr et auto-suffisant qui contient des informations sur l'utilisateur authentifié (les "claims"). Il est signé numériquement, garantissant son intégrité et son authenticité. Le serveur n'a pas besoin de maintenir un état de session pour valider le jeton, ce qui simplifie l'architecture et améliore la scalabilité.

L'architecture typique avec JWT implique les étapes suivantes :

1. L'utilisateur envoie ses identifiants (nom d'utilisateur/mot de passe) à une API d'authentification.
2. Le serveur valide ces identifiants et, en cas de succès, génère un JWT qu'il renvoie au client.
3. Le client stocke ce JWT (généralement dans le stockage local ou un cookie HttpOnly) et l'inclut dans l'en-tête Authorization: Bearer <token> de toutes les requêtes subséquentes vers les API sécurisées.
4. Pour chaque requête sécurisée, le serveur intercepte le JWT, le valide (signature, expiration, claims) et, s'il est valide, autorise l'accès à la ressource.

Implémentation d'une chaîne de filtres JWT avec Spring Security 6

L'intégration de JWT dans Spring Security 6 passe principalement par la configuration d'une chaîne de filtres de sécurité personnalisée. Le principe consiste à intercepter chaque requête HTTP pour extraire et valider le JWT avant que la requête n'atteigne les contrôleurs.

Dépendances nécessaires

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Configuration de Spring Security 6

La configuration de la chaîne de filtres se fait via une classe annotée @Configuration et @EnableWebSecurity. Le bean SecurityFilterChain est central.

<pre><code>
package com.latysamba.security;

import com.latysamba.jwt.JwtAuthenticationFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfiguration {

    private final JwtAuthenticationFilter jwtAuthFilter;
    private final AuthenticationProvider authenticationProvider;

    public SecurityConfiguration(JwtAuthenticationFilter jwtAuthFilter, AuthenticationProvider authenticationProvider) {
        this.jwtAuthFilter = jwtAuthFilter;
        this.authenticationProvider = authenticationProvider;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // Désactive CSRF pour les API REST
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/v1/auth/**").permitAll() // Routes publiques pour l'authentification
                .anyRequest().authenticated() // Toutes les autres routes nécessitent une authentification
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS) // Stratégie sans état pour JWT
            )
            .authenticationProvider(authenticationProvider)
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); // Ajout de notre filtre JWT

        return http.build();
    }
}
</code></pre>

Dans cet extrait, on configure :

• La désactivation de CSRF, typique des API REST.
• Les chemins accessibles publiquement (/api/v1/auth/**) et ceux nécessitant une authentification.
• Une politique de gestion de session STATELESS, essentielle pour JWT.
• L'ajout de notre JwtAuthenticationFilter personnalisé avant le filtre d'authentification Spring Security par défaut.

Le Filtre d'Authentification JWT

Ce filtre est responsable de l'extraction et de la validation du JWT à partir de l'en-tête de chaque requête. S'il est valide, il configure le contexte de sécurité de Spring.

<pre><code>
package com.latysamba.jwt;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.lang.NonNull;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtService jwtService;
    private final UserDetailsService userDetailsService;

    public JwtAuthenticationFilter(JwtService jwtService, UserDetailsService userDetailsService) {
        this.jwtService = jwtService;
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal(
            @NonNull HttpServletRequest request,
            @NonNull HttpServletResponse response,
            @NonNull FilterChain filterChain
    ) throws ServletException, IOException {
        final String authHeader = request.getHeader("Authorization");
        final String jwt;
        final String userEmail;

        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }

        jwt = authHeader.substring(7);
        userEmail = jwtService.extractUsername(jwt); // Extrait l'email de l'utilisateur du JWT

        if (userEmail != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(userEmail);
            if (jwtService.isTokenValid(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
                        userDetails,
                        null,
                        userDetails.getAuthorities()
                );
                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken); // Met à jour le contexte de sécurité
            }
        }
        filterChain.doFilter(request, response);
    }
}
</code></pre>

Gestion des utilisateurs et de l'authentification

Pour que le système JWT fonctionne, il faut un moyen de gérer les utilisateurs et de générer les jetons lors de la connexion.

Service de Détails Utilisateur (UserDetailsService)

Spring Security utilise une interface UserDetailsService pour charger les informations utilisateur. Une implémentation personnalisée permet de récupérer les utilisateurs depuis une base de données ou un autre référentiel.

<pre><code>
package com.latysamba.service;

import com.latysamba.repository.UserRepository;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class ApplicationUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    public ApplicationUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return userRepository.findByEmail(username)
                .orElseThrow(() -> new UsernameNotFoundException("Utilisateur non trouvé avec l'email : " + username));
    }
}
</code></pre>

Le UserRepository serait une interface JPA simple pour interagir avec une base de données.

Endpoint d'Authentification (Login)

Un contrôleur dédié gérera les requêtes de connexion et la génération du JWT.

<pre><code>
package com.latysamba.auth;

import com.latysamba.jwt.JwtService;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/auth")
public class AuthenticationController {

    private final AuthenticationManager authenticationManager;
    private final UserDetailsService userDetailsService;
    private final JwtService jwtService;

    public AuthenticationController(AuthenticationManager authenticationManager,
                                    UserDetailsService userDetailsService,
                                    JwtService jwtService) {
        this.authenticationManager = authenticationManager;
        this.userDetailsService = userDetailsService;
        this.jwtService = jwtService;
    }

    @PostMapping("/authenticate")
    public ResponseEntity<AuthenticationResponse> authenticate(@RequestBody AuthenticationRequest request) {
        authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(request.getEmail(), request.getPassword())
        );
        UserDetails userDetails = userDetailsService.loadUserByUsername(request.getEmail());
        String jwtToken = jwtService.generateToken(userDetails);
        return ResponseEntity.ok(new AuthenticationResponse(jwtToken));
    }
}

// Classes AuthenticationRequest et AuthenticationResponse seraient des POJO simples pour gérer les requêtes et réponses.
</code></pre>

Conclusion

La sécurisation des API REST avec Spring Security 6 et JWT est une approche puissante et flexible pour protéger les applications Spring Boot 3.x. En adoptant une stratégie stateless basée sur des jetons, les développeurs peuvent construire des architectures plus scalables et résilientes. Les exemples de code présentés ici offrent une base solide pour implémenter ces mécanismes. Laty Gueye Samba, en tant qu'Expert Java Spring Boot Angular, conseille vivement d'intégrer ces pratiques dès le début du cycle de développement pour garantir la robustesse et la fiabilité des systèmes.

Il est crucial de toujours se référer à la documentation officielle pour les dernières mises à jour et les meilleures pratiques de sécurité.

Ressources Officielles :

• Documentation officielle de Spring Security
• Documentation officielle de Spring Boot
• Introduction aux JSON Web Tokens (JWT)