OAuth 2.0 et autorisation JWT en Java : guide étape par étape

OAuth 2.0 et autorisation JWT en Java : en pratique

Les applications web et API modernes ne se passent rarement de mécanismes d'authentification et d'autorisation. Les deux normes les plus populaires — OAuth 2.0 et JWT (JSON Web Token) — permettent de transmettre en toute sécurité les données utilisateur et de donner accès aux ressources. Dans cet article, nous allons voir comment implémenter OAuth 2.0 et l'autorisation JWT en Java sur un exemple pratique utilisant Spring Boot. Vous apprendrez à configurer un serveur d'autorisation, générer et vérifier des jetons JWT, ainsi qu'à sécuriser les points de terminaison de votre API REST.

Qu'est-ce que OAuth 2.0 et JWT : aperçu rapide

OAuth 2.0 est un protocole d'accès délégué qui permet aux applications tierces d'obtenir un accès limité aux ressources d'un utilisateur sans transmettre ses identifiants. Il est largement utilisé pour la connexion via les réseaux sociaux (Google, Facebook) et pour la sécurisation des API.

JWT (JSON Web Token) est un format de jeton compact et autonome qui contient des informations sur l'utilisateur (claims) et est signé pour vérifier son intégrité. JWT est souvent utilisé comme jeton d'accès dans OAuth 2.0, car il ne nécessite pas de stockage côté serveur et se transmet facilement dans les en-têtes HTTP.

En pratique, OAuth 2.0 définit le flux (flow) d'obtention du jeton, tandis que JWT en définit le format. Ensemble, ils forment un système d'autorisation puissant et sécurisé.

Configuration du projet Spring Boot avec les dépendances

Pour commencer, créons un projet Spring Boot de base. Nous utiliserons Spring Security, Spring Web et une bibliothèque pour travailler avec JWT (par exemple, jjwt).

Ajoutez les dépendances suivantes dans votre pom.xml (Maven) ou build.gradle (Gradle) :

<!-- Maven -->\n<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-security</artifactId>\n</dependency>\n<dependency>\n    <groupId>org.springframework.boot</groupId>\n    <artifactId>spring-boot-starter-web</artifactId>\n</dependency>\n<dependency>\n    <groupId>io.jsonwebtoken</groupId>\n    <artifactId>jjwt-api</artifactId>\n    <version>0.12.3</version>\n</dependency>\n<dependency>\n    <groupId>io.jsonwebtoken</groupId>\n    <artifactId>jjwt-impl</artifactId>\n    <version>0.12.3</version>\n    <scope>runtime</scope>\n</dependency>\n<dependency>\n    <groupId>io.jsonwebtoken</groupId>\n    <artifactId>jjwt-jackson</artifactId>\n    <version>0.12.3</version>\n    <scope>runtime</scope>\n</dependency>

Créons maintenant une classe de configuration de sécurité qui désactivera CSRF et définira la chaîne de filtres.

Implémentation du serveur d'autorisation et génération de JWT

Pour OAuth 2.0, nous aurons besoin d'un point de terminaison qui acceptera les identifiants du client et retournera un jeton JWT. Dans le cas le plus simple, cela peut être une simulation de serveur d'autorisation.

Créons un service pour travailler avec JWT :

import io.jsonwebtoken.Jwts;\nimport io.jsonwebtoken.SignatureAlgorithm;\nimport io.jsonwebtoken.security.Keys;\nimport org.springframework.stereotype.Service;\n\nimport javax.crypto.SecretKey;\nimport java.util.Date;\n\n@Service\npublic class JwtService {\n\n    private final SecretKey secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256);\n    private final long expirationMs = 3600000; // 1 heure\n\n    public String generateToken(String username) {\n        Date now = new Date();\n        Date expiryDate = new Date(now.getTime() + expirationMs);\n\n        return Jwts.builder()\n                .subject(username)\n                .issuedAt(now)\n                .expiration(expiryDate)\n                .signWith(secretKey)\n                .compact();\n    }\n\n    public String