Jetons JWT en Kotlin : Guide complet avec exemples de code

Jetons JWT en Kotlin : Guide complet pour les développeurs

JSON Web Token (JWT) est un format compact et sécurisé pour les URL, permettant de transmettre des assertions (claims) entre deux parties. Dans l'écosystème Kotlin, JWT est largement utilisé pour l'authentification, l'autorisation et l'échange de données dans les microservices, les applications mobiles et les applications web sur Ktor ou Spring Boot. Dans cet article, nous allons voir comment créer, signer et vérifier des jetons JWT en Kotlin en utilisant les bibliothèques populaires : JJWT (Java JWT) et Auth0 java-jwt.

Qu'est-ce que JWT et pourquoi en a-t-on besoin en Kotlin ?

Un JWT se compose de trois parties : l'en-tête (header), la charge utile (payload) et la signature (signature). En Kotlin, les jetons JWT permettent de :

• Implémenter une authentification sans état (stateless) (le serveur ne stocke pas de sessions).
• Transmettre les rôles et les droits d'accès (claims).
• Travailler avec des systèmes distribués et des API.
• S'intégrer avec OAuth2 et OpenID Connect.

Installation des bibliothèques pour travailler avec JWT en Kotlin

Pour les projets Kotlin/JVM, deux bibliothèques sont les plus adaptées : io.jsonwebtoken:jjwt (JJWT) et com.auth0:java-jwt. Ajoutez les dépendances dans build.gradle.kts :

// build.gradle.ktsdependencies {    // JJWT (recommandé)    implementation("io.jsonwebtoken:jjwt-api:0.12.6")    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.6")    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.6") // pour JSON

    // Auth0 java-jwt    implementation("com.auth0:java-jwt:4.4.0")}

Création d'un jeton JWT avec JJWT (Kotlin)

JJWT fournit une API fluide et claire. Voici un exemple de création d'un jeton avec signature HMAC-SHA256 :

import io.jsonwebtoken.Jwtsimport io.jsonwebtoken.SignatureAlgorithmimport io.jsonwebtoken.security.Keysimport java.util.Date

fun createJwtToken(userId: String, role: String): String {    val secretKey = Keys.hmacShaKeyFor("my_secret_key_32_bytes_long!!".toByteArray())

    val token = Jwts.builder()        .setSubject(userId)        .claim("role", role)        .setIssuedAt(Date())        .setExpiration(Date(System.currentTimeMillis() + 3600_000)) // 1 heure        .signWith(secretKey, SignatureAlgorithm.HS256)        .compact()

    return token}

Vérification et analyse d'un jeton JWT

Pour valider le jeton, utilisez Jwts.parserBuilder(). Exemple de vérification avec extraction des claims :

import io.jsonwebtoken.Jwtsimport io.jsonwebtoken.security.Keys

fun validateToken(token: String): Map<String, Any>? {    return try {        val secretKey = Keys.hmacShaKeyFor("my_secret_key_32_bytes_long!!".toByteArray())        val claims = Jwts.parserBuilder()            .setSigningKey(secretKey)            .build()            .parseClaimsJws(token)            .body

        claims    } catch (e: Exception) {        println("Jeton invalide : ${e.message}")        null    }}

Travailler avec JWT via Auth0 java-jwt (Kotlin)

La bibliothèque Auth0 est également populaire. Exemple de création et de vérification d'un jeton avec signature RSA :

import com.auth0.jwt.JWTimport com.auth0.jwt.algorithms.Algorithmimport com.auth0.jwt.interfaces.DecodedJWTimport java.security.interfaces.RSAPrivateKeyimport java.security.interfaces.RSAPublicKeyimport java.util.Date

// Génération du jetonfun createRsaToken(userId: String, privateKey: RSAPrivateKey): String {    val algorithm = Algorithm.RSA256(null, privateKey)    return JWT.create()        .withSubject(userId)        .withIssuer("auth0")        .withExpiresAt(Date(System.currentTimeMillis() + 3600_000))        .sign(algorithm)}

// Vérification du jetonfun verifyRsaToken(token: String, publicKey: RSAPublicKey): DecodedJWT? {    return try {        val algorithm = Algorithm.RSA256(publicKe