Autorisierung und Authentifizierung in Kotlin: JWT, Spring Security und Ktor

Autorisierung und Authentifizierung in Kotlin: vollständiger Leitfaden

In der modernen Webentwicklung mit Kotlin beginnt die Anwendungssicherheit mit der korrekten Implementierung der Authentifizierung (Überprüfung der Benutzeridentität) und Autorisierung (Überprüfung der Zugriffsrechte). In diesem Artikel betrachten wir die grundlegenden Ansätze, Bibliotheken und Werkzeuge zur Implementierung dieser Mechanismen auf den Plattformen Spring Boot und Ktor.

Grundlegende Konzepte

Bevor wir zum Code übergehen, klären wir die Begriffe:

• Authentifizierung — der Prozess der Überprüfung, ob ein Benutzer derjenige ist, der er vorgibt zu sein (normalerweise durch Login/Passwort, Token oder Biometrie).
• Autorisierung — die Bestimmung der Zugriffsrechte eines authentifizierten Benutzers (z. B. Zugriff auf bestimmte Routen oder Daten).
• JWT (JSON Web Token) — ein kompaktes und eigenständiges Token zur Übertragung von Daten zwischen Parteien.
• BCrypt — ein Algorithmus zum Hashen von Passwörtern mit Salt, resistent gegen Brute-Force-Angriffe.

Authentifizierung mit JWT in Spring Boot

Spring Security bietet eine leistungsstarke Infrastruktur für die Authentifizierung. Betrachten wir die Implementierung der JWT-Authentifizierung unter Verwendung der Bibliothek 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")}

Erstellen wir eine Utility-Klasse für die Arbeit mit 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 Stunde

    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        }    }}

Authentifizierungsfilter für Spring Security

Jetzt erstellen wir einen Filter, der Anfragen abfängt und das JWT-Token überprüft:

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