Authentification et autorisation en Java : Spring Security et JWT

Authentification et autorisation en Java : Spring Security et JWT

L'organisation d'un accès sécurisé aux ressources est l'une des tâches clés lors du développement d'applications web en Java. Dans cet article, nous allons aborder deux concepts fondamentaux : l'authentification (vérification de l'identité de l'utilisateur) et l'autorisation (vérification des droits d'accès). Nous examinerons des exemples pratiques utilisant le framework populaire Spring Security et la technologie JSON Web Tokens (JWT).

1. Concepts de base

Avant de passer au code, il est important de bien distinguer les termes :

• Authentification (Authentication) — le processus de vérification de l'identité de l'utilisateur. Généralement effectué via un identifiant et un mot de passe, la biométrie ou des jetons.
• Autorisation (Authorization) — le processus de détermination de ce que l'utilisateur est autorisé à faire. Par exemple, l'accès à certains points de terminaison API ou fonctionnalités de l'application.

Dans les applications Java modernes, pour implémenter ces mécanismes, on utilise le plus souvent la combinaison Spring Security + JWT. JWT permet de stocker les informations sur l'utilisateur dans un jeton compact, facile à transmettre entre le client et le serveur.

2. Configuration de Spring Security avec JWT

Ajoutons les dépendances nécessaires dans pom.xml (Maven) :

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-security</artifactId></dependency><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>

3. Création d'un service pour travailler avec JWT

Créons une classe JwtService qui sera responsable de la génération et de la vérification des jetons :

import io.jsonwebtoken.Claims;import io.jsonwebtoken.Jwts;import io.jsonwebtoken.SignatureAlgorithm;import io.jsonwebtoken.security.Keys;import org.springframework.stereotype.Service;

import javax.crypto.SecretKey;import java.util.Date;import java.util.HashMap;import java.util.Map;

@Servicepublic class JwtService {

    private final SecretKey secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256);    private final long expirationMs = 86400000; // 24 heures

    public String generateToken(String username) {        Map<String, Object> claims = new HashMap<>();        return Jwts.builder()                .setClaims(claims)                .setSubject(username)                .setIssuedAt(new Date())                .setExpiration(new Date(System.currentTimeMillis() + expirationMs))                .signWith(secretKey)                .compact();    }

    public String extractUsername(String token) {        return extractAllClaims(token).getSubject();    }

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

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

    private boolean isTokenExpired(String token) {        return extractAllClaims(token).getExpiration().befo