ISSUE-10 JWT Util 클래스 구현

buildSrc/src/main/kotlin/Versions.kt

@@ -5,6 +5,6 @@ object Versions {
     const val SPRING_BOOT = "3.2.5"
     const val SPRING_DEPENDENCY_MANAGEMENT = "1.1.5"
     const val MYSQL = "8.0.33"
-    const val JJWT = "0.12.5"
+    const val JJWT = "0.12.6"
     const val JDK = 17
-}
+}

core/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
 
 dependencies {
     api(project(":domain"))
+    implementation(project(":support:jwt"))
 
     implementation("org.springframework.boot:spring-boot-starter:${Versions.SPRING_BOOT}")
     compileOnly("org.springframework.boot:spring-boot-starter-jdbc:${Versions.SPRING_BOOT}")

core/src/main/kotlin/org/doorip/core/auth/JwtService.kt

@@ -1,13 +1,19 @@
 package org.doorip.core.auth
 
 import org.doorip.domain.UserId
-import org.springframework.stereotype.Component
+import org.doorip.support.jwt.JwtProvider
+import org.doorip.support.jwt.JwtSecretKey
+import org.springframework.stereotype.Service
 
-@Component
-internal class JwtService : AccessTokenUseCase {
+@Service
+internal class JwtService(
+    private val jwtProvider: JwtProvider,
+    private val jwtSecretKey: JwtSecretKey,
+) : AccessTokenUseCase {
 
     override fun getUserId(token: String): UserId? {
-        // TODO
-        return null
+        val subject = jwtProvider.validateAndGetSubject(token, jwtSecretKey) ?: return null
+
+        return UserId(subject.toLong())
     }
 }

core/src/main/kotlin/org/doorip/core/config/JwtConfig.kt

@@ -0,0 +1,18 @@
+package org.doorip.core.config
+
+import org.doorip.support.jwt.JwtProvider
+import org.doorip.support.jwt.JwtSecretKey
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@EnableConfigurationProperties(JwtProperties::class)
+@Configuration
+internal class JwtConfig {
+
+    @Bean
+    fun jwtProvider(): JwtProvider = JwtProvider()
+
+    @Bean
+    fun jwtSecretKey(jwtProperties: JwtProperties): JwtSecretKey = JwtSecretKey(jwtProperties.secret)
+}

core/src/main/kotlin/org/doorip/core/config/JwtProperties.kt

@@ -0,0 +1,8 @@
+package org.doorip.core.config
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+@ConfigurationProperties(prefix = "jwt")
+data class JwtProperties(
+    val secret: String,
+)

core/src/main/resources/application-jwt.yml

@@ -0,0 +1,2 @@
+jwt:
+    secret: ${JWT_SECRET_KEY}

domain/src/main/kotlin/org/doorip/domain/DooripException.kt

@@ -12,15 +12,8 @@ sealed class ClientException(
     message: String,
 ) : DooripException(code, message)
 
-class UnauthorizedException(
-    code: String,
-    message: String,
-) : ClientException(code, message)
-
-class UnauthenticatedException(
-    code: String,
-    message: String,
-) : ClientException(code, message)
+data object UnauthorizedException : ClientException("e4030", "인가 과정에서 예외가 발생했습니다.") { private fun readResolve(): Any = UnauthorizedException }
+data object UnauthenticatedException : ClientException("e4010", "인증 과정에서 예외가 발생했습니다. (ex. AT 만료 or RT 만료)") { private fun readResolve(): Any = UnauthenticatedException }
 
 data object InvalidRequestValueException : ClientException("e4000", "잘못된 요청입니다.") { private fun readResolve(): Any = InvalidRequestValueException }
 data object MethodNotAllowedException : ClientException("e4050", "잘못된 HTTP method 요청입니다.") { private fun readResolve(): Any = MethodNotAllowedException }

presentation/support/auth/src/main/kotlin/org/doorip/presentation/support/auth/TokenAuthenticationFilter.kt

@@ -49,7 +49,6 @@ internal class TokenAuthenticationFilter(
         val authentication = TokenAuthentication(token, userId, details)
 
         val securityContext = SecurityContextHolder.getContext()
-
         securityContext.authentication = authentication
     }
 

settings.gradle.kts

@@ -5,4 +5,5 @@ include(
     "domain",
     "gateway:rdb",
     "support:yaml",
+    "support:jwt",
 )

support/jwt/build.gradle.kts

@@ -0,0 +1,12 @@
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+
+dependencies {
+    implementation("io.jsonwebtoken:jjwt-api:${Versions.JJWT}")
+    runtimeOnly("io.jsonwebtoken:jjwt-impl:${Versions.JJWT}")
+    runtimeOnly("io.jsonwebtoken:jjwt-jackson:${Versions.JJWT}")
+}
+
+tasks {
+    withType<Jar> { enabled = true }
+    withType<BootJar> { enabled = false }
+}

support/jwt/src/main/kotlin/org/doorip/support/jwt/Extensions.kt

@@ -0,0 +1,10 @@
+package org.doorip.support.jwt
+
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.util.*
+
+fun LocalDateTime.toDate(): Date {
+    val instant = this.atZone(ZoneId.systemDefault()).toInstant()
+    return Date.from(instant)
+}

support/jwt/src/main/kotlin/org/doorip/support/jwt/JwtProvider.kt

@@ -0,0 +1,87 @@
+package org.doorip.support.jwt
+
+import com.fasterxml.jackson.core.JsonParseException
+import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.DatabindException
+import com.fasterxml.jackson.databind.ObjectMapper
+import io.jsonwebtoken.Claims
+import io.jsonwebtoken.JwtException
+import io.jsonwebtoken.JwtParser
+import io.jsonwebtoken.Jwts
+import java.security.PublicKey
+import java.time.LocalDateTime
+import java.time.LocalDateTime.now
+import java.util.*
+import javax.crypto.SecretKey
+
+class JwtProvider {
+    private val objectMapper = ObjectMapper()
+    private val typeReference = object : TypeReference<Map<String, String>>() {}
+
+    fun generate(id: String, expiration: LocalDateTime, key: SignatureKey): String {
+        return Jwts.builder()
+            .issuedAt(now().toDate())
+            .expiration(expiration.toDate())
+            .subject(id)
+            .signWith(key.key)
+            .compact()
+    }
+
+    fun validateAndGetSubject(token: String, key: SignatureKey): String? {
+        val payload = parsePayload(token, key) ?: return null
+        return payload.subject
+    }
+
+    fun validateAndGetSubject(token: String, key: SignatureKey, iss: String, aud: String): String? {
+        val payload = parsePayload(token, key) ?: return null
+        if (payload.issuer == iss && payload.audience.contains(aud)) {
+            return payload.subject
+        }
+        return null
+    }
+
+    fun validateAndGetClaim(token: String, key: SignatureKey, claimName: String): String? {
+        val payload = parsePayload(token, key) ?: return null
+        return payload.get(claimName, String::class.java)
+    }
+
+    fun parseHeader(token: String): Map<String, String>? {
+        try {
+            val header = token.split(".")[0]
+            val decoder = Base64.getUrlDecoder()
+            val decoded = String(decoder.decode(header))
+            return objectMapper.readValue(decoded, typeReference)
+        } catch (e: DatabindException) {
+            return null
+        } catch (e: JsonParseException) {
+            return null
+        } catch (e: IndexOutOfBoundsException) {
+            return null
+        }
+    }
+
+    private fun parsePayload(token: String, key: SignatureKey): Claims? {
+        try {
+            val parser = when (val signatureKey = key.key) {
+                is SecretKey -> generateParser(signatureKey)
+                is PublicKey -> generateParser(signatureKey)
+                else -> return null
+            }
+            return parser.parseSignedClaims(token).payload
+        } catch (e: JwtException) {
+            return null
+        }
+    }
+
+    private fun generateParser(key: SecretKey): JwtParser {
+        return Jwts.parser()
+            .verifyWith(key)
+            .build()
+    }
+
+    private fun generateParser(key: PublicKey): JwtParser {
+        return Jwts.parser()
+            .verifyWith(key)
+            .build()
+    }
+}

support/jwt/src/main/kotlin/org/doorip/support/jwt/JwtSecretKey.kt

@@ -0,0 +1,13 @@
+package org.doorip.support.jwt
+
+import io.jsonwebtoken.security.Keys
+import java.security.Key
+
+class JwtSecretKey(
+    private val secret: String,
+) : SignatureKey {
+
+    override val key: Key by lazy {
+        Keys.hmacShaKeyFor(secret.toByteArray())
+    }
+}

support/jwt/src/main/kotlin/org/doorip/support/jwt/RSAPublicKey.kt

@@ -0,0 +1,34 @@
+package org.doorip.support.jwt
+
+import java.math.BigInteger
+import java.security.Key
+import java.security.KeyFactory
+import java.security.spec.RSAPublicKeySpec
+import java.util.*
+
+class RSAPublicKey(
+    private val n: String,
+    private val e: String,
+    private val type: String,
+) : SignatureKey {
+
+    override val key: Key? by lazy {
+        try {
+            val decoder = Base64.getUrlDecoder()
+
+            val nBytes = decoder.decode(n)
+            val eBytes = decoder.decode(e)
+
+            val n = BigInteger(1, nBytes)
+            val e = BigInteger(1, eBytes)
+
+            val rsaPublicKeySpec = RSAPublicKeySpec(n, e)
+
+            val keyFactory = KeyFactory.getInstance(type)
+
+            keyFactory.generatePublic(rsaPublicKeySpec)
+        } catch (e: Exception) {
+            null
+        }
+    }
+}

support/jwt/src/main/kotlin/org/doorip/support/jwt/SignatureKey.kt

@@ -0,0 +1,7 @@
+package org.doorip.support.jwt
+
+import java.security.Key
+
+interface SignatureKey {
+    val key: Key?
+}