Kotlin में प्रमाणीकरण और अधिकार: JWT, Spring Security और Ktor

Kotlin में प्रमाणीकरण और अधिकार: संपूर्ण गाइड

आधुनिक Kotlin वेब डेवलपमेंट में, एप्लिकेशन की सुरक्षा प्रमाणीकरण (उपयोगकर्ता की पहचान सत्यापित करना) और अधिकार (पहुँच अधिकार जाँचना) के सही कार्यान्वयन से शुरू होती है। इस लेख में, हम Spring Boot और Ktor प्लेटफॉर्म पर इन तंत्रों को लागू करने के मुख्य तरीकों, लाइब्रेरीज़ और टूल्स पर चर्चा करेंगे।

मुख्य अवधारणाएँ

कोड पर जाने से पहले, शब्दों को समझ लेते हैं:

• प्रमाणीकरण (Authentication) — यह सत्यापित करने की प्रक्रिया कि उपयोगकर्ता वही है जो वह होने का दावा करता है (आमतौर पर लॉगिन/पासवर्ड, टोकन या बायोमेट्रिक के माध्यम से)।
• अधिकार (Authorization) — प्रमाणित उपयोगकर्ता के पहुँच अधिकार निर्धारित करना (जैसे, विशिष्ट रूट या डेटा तक पहुँच)।
• JWT (JSON Web Token) — पक्षों के बीच डेटा स्थानांतरित करने के लिए एक कॉम्पैक्ट और स्व-निहित टोकन।
• BCrypt — नमक के साथ पासवर्ड हैशिंग एल्गोरिदम, जो ब्रूट-फोर्स हमलों के प्रति प्रतिरोधी है।

Spring Boot में JWT के साथ प्रमाणीकरण

Spring Security प्रमाणीकरण के लिए एक शक्तिशाली बुनियादी ढाँचा प्रदान करता है। आइए io.jsonwebtoken:jjwt लाइब्रेरी का उपयोग करके JWT प्रमाणीकरण के कार्यान्वयन को देखें।

// build.gradle.kts
dependencies {
    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")
}

JWT के साथ काम करने के लिए एक यूटिलिटी क्लास बनाएँ:

import io.jsonwebtoken.*
import io.jsonwebtoken.security.Keys
import org.springframework.stereotype.Component
import java.security.Key
import java.util.*

@Component
class JwtUtil {
    private val secretKey: Key = Keys.secretKeyFor(SignatureAlgorithm.HS256)
    private val expirationMs: Long = 3600000 // 1 घंटा

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

Spring Security के लिए प्रमाणीकरण फ़िल्टर

अब एक फ़िल्टर बनाएँ जो अनुरोधों को इंटरसेप्ट करेगा और JWT टोकन की जाँच करेगा:

import jakarta.servlet.FilterChain
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource
import org.springframework.stereotype.Component
import org.springframework.web.filter.OncePerRequestFilter

@Component
class 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, response)
            return
        }

        val token = authHeader.substring(7)