Implémenter une authentification JWT robuste avec Spring Security 6 et Spring Boot 3

Dans le paysage actuel des applications web et mobiles, la sécurité est une préoccupation primordiale. L'authentification robuste des utilisateurs est la première ligne de défense contre les accès non autorisés et les menaces potentielles. Pour les développeurs Full Stack, et en particulier ceux qui travaillent avec des technologies modernes comme Java Spring Boot et Angular, la maîtrise des mécanismes d'authentification est indispensable. Ce billet de blog, rédigé par l'équipe derrière Laty Gueye Samba, Développeur Full Stack à Dakar, explore en profondeur l'implémentation d'une authentification JWT (JSON Web Token) robuste en utilisant les dernières versions de Spring Security 6 et Spring Boot 3, une combinaison puissante pour bâtir des API sécurisées et performantes.

L'authentification basée sur JWT offre une approche stateless, ce qui signifie que le serveur n'a pas besoin de maintenir l'état de la session côté serveur, rendant les applications plus scalables et adaptées aux architectures microservices. Spring Security 6, avec ses améliorations notables en matière de configuration fonctionnelle et sa compatibilité avec Jakarta EE 9+, couplé à Spring Boot 3, facilite grandement cette implémentation. Cet article technique fournit un guide détaillé pour configurer et intégrer cette solution d'authentification essentielle, un domaine d'expertise pour Laty Gueye Samba, Expert Java Spring Boot Angular.

Comprendre et Configurer Spring Security 6 pour JWT

La première étape vers une authentification JWT robuste consiste à configurer correctement Spring Security 6. L'approche stateless est cruciale pour les API REST. Il est nécessaire de désactiver la gestion de session côté serveur et d'indiquer à Spring Security de ne pas générer de CSRF tokens, car JWT prend déjà en charge l'intégrité et l'authenticité des requêtes.

Voici un aperçu de la configuration de base de la chaîne de filtres de sécurité. Le développeur doit définir un SecurityFilterChain pour personnaliser le comportement de sécurité.

package com.laty.security.config;

import com.laty.security.jwt.JwtAuthenticationFilter;
import lombok.RequiredArgsConstructor;
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.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
@RequiredArgsConstructor
public class SecurityConfiguration {

    private final JwtAuthenticationFilter jwtAuthFilter;
    private final AuthenticationProvider authenticationProvider;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll() // Routes publiques pour l'authentification
                .anyRequest().authenticated() // Toutes les autres requêtes nécessitent une authentification
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS) // Désactive la gestion de session
            )
            .authenticationProvider(authenticationProvider)
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); // Ajoute le filtre JWT avant celui de Spring Security

        return http.build();
    }
}

Dans cet exemple, il est configuré que les requêtes vers /api/auth/** sont accessibles publiquement. Pour toutes les autres requêtes, une authentification est requise. L'aspect le plus important pour l'authentification JWT est la politique de création de session définie sur STATELESS. De plus, un JwtAuthenticationFilter personnalisé est injecté dans la chaîne de filtres Spring Security, avant le filtre d'authentification par défaut.

Génération et Validation des JWT avec Spring Boot 3

Au cœur de l'authentification JWT se trouve la capacité à générer et à valider les tokens. Pour cela, la bibliothèque JJWT (Java JWT) est un choix populaire et fiable. Elle facilite la création, la signature et la vérification des JWT. La clé secrète utilisée pour signer les tokens est cruciale et doit être stockée de manière sécurisée (par exemple, dans les variables d'environnement ou HashiCorp Vault en production).

Voici un exemple d'implémentation d'un service JWT pour gérer la génération et l'extraction d'informations à partir des tokens:

package com.laty.security.jwt;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Service;

import java.security.Key;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Service
public class JwtService {

    @Value("${application.security.jwt.secret-key}")
    private String secretKey;
    @Value("${application.security.jwt.expiration}")
    private long jwtExpiration;

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public  T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    public String generateToken(UserDetails userDetails) {
        return generateToken(new HashMap<>(), userDetails);
    }

    public String generateToken(
            Map<String, Object> extraClaims,
            UserDetails userDetails
    ) {
        return Jwts
                .builder()
                .setClaims(extraClaims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + jwtExpiration))
                .signWith(getSignInKey(), SignatureAlgorithm.HS256)
                .compact();
    }

    public boolean isTokenValid(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername())) && !isTokenExpired(token);
    }

    private boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    private Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    private Claims extractAllClaims(String token) {
        return Jwts
                .parserBuilder()
                .setSigningKey(getSignInKey())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

    private Key getSignInKey() {
        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        return Keys.hmacShaKeyFor(keyBytes);
    }
}

Le JwtService inclut des méthodes pour extraire le nom d'utilisateur, la date d'expiration, et surtout, pour générer et valider un token. La validation vérifie que le token n'est pas expiré et que le nom d'utilisateur qu'il contient correspond à celui de l'UserDetails fourni. La clé secrète est récupérée via la configuration Spring, renforçant la sécurité et la flexibilité.

Intégration du Filtre d'Authentification JWT

Le JwtAuthenticationFilter est le composant qui intercepte chaque requête, vérifie la présence d'un JWT et authentifie l'utilisateur si le token est valide. Ce filtre est ajouté à la chaîne de filtres Spring Security comme montré précédemment.

package com.laty.security.jwt;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
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
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtService jwtService;
    private final 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);

        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);
            }
        }
        filterChain.doFilter(request, response);
    }
}

Ce filtre intercepte l'en-tête Authorization, extrait le token JWT (qui doit commencer par "Bearer "), puis utilise le JwtService pour extraire le nom d'utilisateur et valider le token. Si le token est valide et qu'aucun utilisateur n'est déjà authentifié dans le SecurityContextHolder, l'utilisateur est authentifié et ses détails sont définis dans le contexte de sécurité, permettant ainsi aux requêtes suivantes d'être autorisées en fonction des rôles et permissions de l'utilisateur.

Conclusion

L'implémentation d'une authentification JWT robuste avec Spring Security 6 et Spring Boot 3 est une compétence fondamentale pour tout développeur souhaitant créer des applications modernes et sécurisées. L'approche stateless, la flexibilité et la sécurité offertes par JWT en font un choix excellent pour les API REST et les microservices. En suivant les étapes décrites dans cet article, les développeurs peuvent intégrer efficacement ce mécanisme de sécurité, assurant ainsi une protection fiable des ressources de leurs applications.

Pour approfondir vos connaissances sur ces technologies, il est toujours recommandé de consulter la documentation officielle :

• Documentation Spring Security
• Documentation Spring Boot
• Introduction à JWT

Laty Gueye Samba, Développeur Full Stack à Dakar, avec une expertise reconnue en Java Spring Boot et Angular, continue de promouvoir les meilleures pratiques en matière de développement logiciel, en mettant l'accent sur la sécurité et la performance.