Autorisation et authentification en Kotlin : JWT, Spring Security et Ktor

Autorisation et authentification en Kotlin : guide complet

Dans le développement web moderne avec Kotlin, la sécurité de l'application commence par une implémentation correcte de l'authentification (vérification de l'identité de l'utilisateur) et de l'autorisation (vérification des droits d'accès). Dans cet article, nous examinerons les approches principales, les bibliothèques et les outils pour implémenter ces mécanismes sur les plateformes Spring Boot et Ktor.

Concepts de base

Avant de passer au code, clarifions les termes :

• Authentification — processus de vérification que l'utilisateur est bien celui qu'il prétend être (généralement via identifiant/mot de passe, jeton ou biométrie).
• Autorisation — détermination des droits d'accès d'un utilisateur authentifié (par exemple, accès à certaines routes ou données).
• JWT (JSON Web Token) — jeton compact et autonome pour transmettre des données entre les parties.
• BCrypt — algorithme de hachage de mots de passe avec sel, résistant aux attaques par force brute.

Authentification avec JWT dans Spring Boot

Spring Security fournit une infrastructure puissante pour l'authentification. Examinons l'implémentation de l'authentification JWT en utilisant la bibliothèque io.jsonwebtoken:jjwt.

// build.gradle.ktsdependencies {    implementation("org.springframework.boot:spring-boot-starter-security")    implementation("io.jsonwebtoken:jjwt-api:0.12.3")    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.3")    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.3")}

Créons une classe utilitaire pour travailler avec JWT :

import io.jsonwebtoken.*import io.jsonwebtoken.security.Keysimport org.springframework.stereotype.Componentimport java.security.Keyimport java.util.*

@Componentclass JwtUtil {    private val secretKey: Key = Keys.secretKeyFor(SignatureAlgorithm.HS256)    private val expirationMs: Long = 3600000 // 1 heure

    fun generateToken(username: String): String {        return Jwts.builder()            .subject(username)            .issuedAt(Date())            .expiration(Date(System.currentTimeMillis() + expirationMs))            .signWith(secretKey)            .compact()    }

    fun extractUsername(token: String): String? {        return try {            Jwts.parser().verifyWith(secretKey).build()                .parseSignedClaims(token).payload.subject        } catch (e: Exception) {            null        }    }

    fun validateToken(token: String): Boolean {        return try {            Jwts.parser().verifyWith(secretKey).build()                .parseSignedClaims(token)            true        } catch (e: JwtException) {            false        }    }}

Filtre d'authentification pour Spring Security

Créons maintenant un filtre qui interceptera les requêtes et vérifiera le jeton JWT :

import jakarta.servlet.FilterChainimport jakarta.servlet.http.HttpServletRequestimport jakarta.servlet.http.HttpServletResponseimport org.springframework.security.authentication.UsernamePasswordAuthenticationTokenimport org.springframework.security.core.context.SecurityContextHolderimport org.springframework.security.web.authentication.WebAuthenticationDetailsSourceimport org.springframework.stereotype.Componentimport org.springframework.web.filter.OncePerRequestFilter

@Componentclass JwtAuthFilter(    private val jwtUtil: JwtUtil,    private val userDetailsService: org.springframework.security.core.userdetails.UserDetailsService) : OncePerRequestFilter() {

    override fun doFilterInternal(        request: HttpServletRequest,        response: HttpServletResponse,        chain: FilterChain    ) {        val authHeader = request.getHeader("Authorization")        if (authHeader == null || !authHeader.startsWith("Bearer ")) {            chain.doFilter(request, re