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

OAuth 2.0 et autorisation JWT en Kotlin : pour débutants

Les applications web et API modernes ne se passent que rarement d'un système d'authentification et d'autorisation. Les deux standards les plus populaires dans ce domaine sont OAuth 2.0 et JWT (JSON Web Token). Dans cet article, nous allons voir comment implémenter l'autorisation en Kotlin en utilisant ces technologies. Ce contenu est destiné aux développeurs débutants qui connaissent les bases du langage et du framework Spring Boot.

Qu'est-ce que OAuth 2.0 et JWT ?

Avant d'écrire du code, il est important de comprendre la théorie.

OAuth 2.0 est un protocole d'autorisation qui permet aux applications d'obtenir un accès limité aux ressources d'un utilisateur sans transmettre son identifiant et son mot de passe. Imaginez que vous vous connectez à un site via "Se connecter avec Google" — c'est cela OAuth 2.0.

JWT est un format de jeton compact et autonome. Il se compose de trois parties : l'en-tête (header), la charge utile (payload) et la signature (signature). JWT est souvent utilisé avec OAuth 2.0 pour transmettre des informations d'authentification.

Les flux principaux d'OAuth 2.0 :

• Authorization Code Flow — pour les applications serveur (le plus sécurisé)
• Client Credentials Flow — pour la communication serveur à serveur
• Implicit Flow — obsolète, déconseillé
• Resource Owner Password Flow — uniquement si vous faites confiance au client

Dans cet article, nous nous concentrerons sur le Client Credentials Flow, car il est le plus simple à comprendre et souvent utilisé dans les microservices.

Configuration du projet Spring Boot en Kotlin

Créons un nouveau projet Spring Boot avec le support de Kotlin. Ajoutons les dépendances nécessaires dans build.gradle.kts :

dependencies {    implementation("org.springframework.boot:spring-boot-starter-web")    implementation("org.springframework.boot:spring-boot-starter-security")    implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")    implementation("io.jsonwebtoken:jjwt-api:0.11.5")    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")}

Ces dépendances assurent le support de Spring Security, d'OAuth 2.0 Resource Server et de la bibliothèque JJWT pour travailler avec JWT.

Création de jetons JWT en Kotlin

Écrivons un service pour générer et valider les JWT. C'est la base de notre autorisation.

import io.jsonwebtoken.Jwtsimport io.jsonwebtoken.SignatureAlgorithmimport io.jsonwebtoken.security.Keysimport org.springframework.stereotype.Serviceimport java.util.Date

@Serviceclass JwtService {    private val secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256)    private val expirationMs = 3600000L // 1 heure

    fun generateToken(clientId: String): String {        val now = Date()        val expiryDate = Date(now.time + expirationMs)

        return Jwts.builder()            .setSubject(clientId)            .setIssuedAt(now)            .setExpiration(expiryDate)            .signWith(secretKey)            .compact()    }

    fun validateToken(token: String): Boolean {        return try {            Jwts.parserBuilder()                .setSigningKey(secretKey)                .build()                .parseClaimsJws(token)            true        } catch (e: Exception) {            false        }    }

    fun getClientIdFromToken(token: String): String {        val claims = Jwts.parserBuilder()            .setSigningKey(secretKey)            .build()            .parseClaimsJws(token)            .body        return claims.subject    }}

Dans ce service, nous utilisons une clé symétrique. En production, il est préférable d'utiliser le chiffrement asymétrique (RS256) et