Spring Security 6: Implémenter l'authentification JWT pour une API REST Java 17

Spring Security 6: Implémenter l'authentification JWT pour une API REST Java 17

Dans le paysage actuel du développement d'applications web, la sécurité des API REST est une préoccupation majeure. Avec l'avènement de Spring Security 6 et les dernières avancées de Java 17 et Spring Boot 3, les développeurs disposent d'outils puissants pour construire des systèmes robustes et sécurisés. Cet article explore en détail l'implémentation de l'authentification basée sur les JSON Web Tokens (JWT) pour une API REST Java, une approche devenue un standard de facto pour les microservices et les applications découplées.

L'authentification JWT offre une solution légère et sans état, idéale pour les API REST. Elle permet aux serveurs de ne pas avoir à stocker les informations de session, ce qui simplifie la scalabilité et la gestion de la charge. Pour un Développeur Full Stack Java Spring Boot + Angular comme Laty Gueye Samba, basé à Dakar, Sénégal, la maîtrise de cette technologie est essentielle pour concevoir des applications performantes et sécurisées, répondant aux exigences des projets modernes.

Ce guide propose une démarche pas à pas pour configurer Spring Security 6 afin de gérer l'authentification JWT. Il couvrira la configuration de base de Spring Security, la génération et la validation des tokens JWT, ainsi que l'intégration d'un filtre personnalisé pour intercepter et traiter les tokens entrants, garantissant ainsi une protection efficace des ressources de l'API REST.

Configuration de base de Spring Security 6 pour l'authentification JWT

La première étape cruciale consiste à configurer Spring Security 6 pour qu'il prenne en charge un mécanisme d'authentification sans état, adapté aux JWT. Cela implique de désactiver la protection CSRF (Cross-Site Request Forgery) qui n'est généralement pas nécessaire pour les API REST stateless et de configurer la gestion de session sur Stateless.

Voici un exemple de configuration de la chaîne de filtres de sécurité dans une classe de configuration Spring Boot :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationProvider;
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
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(AbstractHttpConfigurer::disable) // Désactive CSRF pour les API REST
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/api/auth/**").permitAll() // Permet l'accès aux endpoints d'authentification
                .anyRequest().authenticated() // Exige une authentification pour toutes les autres requêtes
            )
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS) // Configure la gestion de session comme stateless
            )
            .authenticationProvider(authenticationProvider)
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class); // Ajoute le filtre JWT avant le filtre d'authentification par nom d'utilisateur/mot de passe

        return http.build();
    }
}

Dans cette configuration de Spring Security, le JwtAuthenticationFilter est injecté dans la chaîne de filtres. Il sera responsable de l'interception des requêtes HTTP, de l'extraction du JWT de l'en-tête d'autorisation et de sa validation. L'AuthenticationProvider est également un composant clé qui définira comment les informations d'identification sont authentifiées.

Génération et Validation des Tokens JWT avec Java 17

La création et la validation des JWT sont au cœur de ce mécanisme d'authentification. Une bibliothèque populaire pour gérer les JWT en Java est JJWT. Il est recommandé d'ajouter la dépendance suivante à votre fichier pom.xml :

<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>

Une classe utilitaire pour générer et extraire des informations des tokens JWT est essentielle. Elle encapsule la logique de signature, de parsing et de validation. Les fonctionnalités offertes par Java 17 simplifient l'écriture de code propre et concis pour ces opérations.

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.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 {

    // Clé secrète (doit être stockée de manière sécurisée et non en clair ici)
    private static final String SECRET_KEY = "VotreCleSecreteTresLongueEtSecuriseePourJWT"; 

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

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

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

    public String generateToken(Map extraClaims, UserDetails userDetails) {
        return Jwts
                .builder()
                .setClaims(extraClaims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 24)) // 24 heures
                .signWith(getSigningKey(), 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(getSigningKey())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

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

Cette classe JwtService fournit les méthodes nécessaires pour générer des tokens (incluant des claims personnalisés), extraire le nom d'utilisateur et vérifier la validité du token. La clé secrète doit être gérée avec une extrême prudence et ne devrait jamais être codée en dur dans une application de production.

Intégration du Filtre JWT dans Spring Security 6

Le JwtAuthenticationFilter est l'élément qui connecte la logique JWT à la chaîne de sécurité de Spring Security 6. Ce filtre intercepte chaque requête, cherche le token JWT dans l'en-tête Authorization, le valide et configure le contexte de sécurité de Spring si le token est valide.

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);

        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, exécuté une seule fois par requête, extrait le JWT, récupère le nom d'utilisateur (ou l'email) et charge les détails de l'utilisateur via le UserDetailsService. Si le token est valide, un objet Authentication est créé et défini dans le SecurityContextHolder, permettant à Spring Security d'autoriser l'accès aux ressources protégées.

Conclusion

L'implémentation de l'authentification JWT avec Spring Security 6, Java 17 et Spring Boot 3 offre une solution moderne et efficace pour sécuriser les API REST. En suivant les étapes décrites dans cet article, les développeurs peuvent construire des systèmes d'authentification sans état, hautement scalables et sécurisés, répondant aux exigences des applications d'entreprise d'aujourd'hui. L'expertise d'un Développeur Full Stack Dakar Sénégal comme Laty Gueye Samba dans ces technologies est cruciale pour le succès des projets complexes.

Pour approfondir vos connaissances sur Spring Security et les JWT, il est vivement recommandé de consulter les ressources officielles :

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