🔥 TIL - Day 74 Kotlin & Springboot 05 SpringSecurity 없이 토큰기반 인증 구현 및 Junit 테스트

전체 소스코드 Github

Spring Security 없이 구현하는 이유

• Spring Security는 굉장히 큰 라이브러리이다. 따라서 완벽하게 이해하는 것이 쉽지 않다.
• 토큰기반 인증의 경우 굳이 SpringSecurity의 필터체인을 이용하지 않아도 구현 가능하다.
• 라이브러리의 기능을 직접 구현할 수 있다면 다른 언어의 프레임워크에 같은 기능을 구현하는데 용이할 것이다.

큰 흐름을 잡아보자.
클라이언트는 회원가입, 로그인, 마이페이지 총 3가지 API에 접근할 수 있다.

• 회원가입, 로그인은 인증을 필요로 하지 않는다.
• 마이페이지의 경우 인증을 필요로 하고 인증은 발급된 토큰을 검증하는 것으로 수행한다.

로그인 전,후로 마이페이지 접근 가능여부로 테스트를 진행한다.

---

📌 Jwt token 생성 및 검증을 위한 유틸클래스

@Component
class JwtUtils {

    val SECRET = "secret"
    val EXP_TIME = 1000 * 60 * 10

    // 토큰생성
    fun generateToken(userId: Long, username: String): String {
        return Jwts.builder()
            .setSubject(username)
            .claim("userId", userId)
            .setExpiration(Date(System.currentTimeMillis() + EXP_TIME))
            .signWith(SignatureAlgorithm.HS256, SECRET)
            .compact()
    }

    // 토큰검증 
    fun verifyToken(token: String): Boolean {
        return try {
            val claims = getAllClaims(token)
            val expiration = claims.expiration
            expiration.after(Date())
        } catch (e: JwtException) {
            false
        } catch (e: IllegalArgumentException) {
            false
        }
    }

    // Claim 조회
    fun getClaim(token: String, key: String ): Any? {
        val claims: Claims = getAllClaims(token)
        return claims[key]
    }

    private fun getAllClaims(token: String): Claims {
        return Jwts.parser()
            .setSigningKey(SECRET)
            .parseClaimsJwt(token).body
    }
}

📌 Http 요청에서 JWT 토큰을 뽑아내는 유틸 클래스

class JwtTokenExtractor {

    companion object{
        const val AUTHORIZATION_HEADER_PREFIX = "Authorization"
        const val BEARER_TYPE_PREFIX = "Bearer "

        fun extract(request: HttpServletRequest): String? {
            val authorization: String? = request.getHeader(AUTHORIZATION_HEADER_PREFIX)
            authorization?.let {
                if(authorization.startsWith(BEARER_TYPE_PREFIX)) {
                    return authorization.substring(BEARER_TYPE_PREFIX.length)
                }
            }
            return null
        }
    }
}

📌 SpringSecurity의 @AuthenticationPrincipal을 대신할 Custom Annotation 작성

Spring Security를 사용하는 경우 현재 인증된 사용자의 정보를 가져오기 위해 SecurityContext의 Authentication을 가져오는 @AuthenticationPrincipal 어노테이션을 매우 자주 사용한다. 동일한 기능을 가지는 어노테이션을 작성해본다.

어노테이션 클래스 생성

@Target(AnnotationTarget.VALUE_PARAMETER) // 생성자 매개변수에 적용
@Retention(AnnotationRetention.RUNTIME)
annotation class LoginUser()

어노테이션 구현 클래스 생성 (HandlerMethodArgumentResolver)

@Component
class LoginUserArgumentResolver(
    private val jwtUtils: JwtUtils,
    private val userRepository: UserRepository
): HandlerMethodArgumentResolver {

    override fun supportsParameter(parameter: MethodParameter): Boolean {
        return parameter.hasParameterAnnotation(LoginUser::class.java)
    }

    override fun resolveArgument(
        parameter: MethodParameter,
        mavContainer: ModelAndViewContainer?,
        webRequest: NativeWebRequest,
        binderFactory: WebDataBinderFactory?
    ): User? {
        val httpServletRequest: HttpServletRequest = webRequest.getNativeRequest(HttpServletRequest::class.java) as HttpServletRequest
        // Http 요청에서 토큰추출
        val token = JwtTokenExtractor.extract(httpServletRequest)
        // 토큰이 존재하는 경우
        token?.let {
            if(jwtUtils.verifyToken(token)) { // 토큰검증
                val userId = jwtUtils.getClaim(token, "id") // 검증된 토큰에서 id값을 뽑아서 User를 조회
                return userRepository.findByIdOrNull(userId as Long)
            }
        }

        return null
    }

    // 토큰에서 user pk 추출
    private fun getUserIdFromToken(token: String): Long? {
        return jwtUtils.getClaim(token, "id") as Long?
    }
}

이제 생성자에서 User를 받는 경우 @LoginUser를 붙여주면 현재 토큰을 소유한 User를 가져올 수 있다.

📌 API 앞 단에서 토큰검증을 수행할 인터셉터 구현

JwtUtils의 검증메서드를 이용해서 요청의 헤더가 토큰을 포함하는 경우 검증을 수행한다.

@Component
class TokenVerifyInterceptor(
    private val jwtUtils: JwtUtils
) : HandlerInterceptor {

    override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
        val method = request.method
        // 사전요청의 경우 pass
        if (method.equals(HttpMethod.OPTIONS)) return true
	// Http 요청에서 토큰 추출
        val token: String? = JwtTokenExtractor.extract(request)
        // 토큰이 존재하는 경우
        token?.let {
            jwtUtils.verifyToken(it) // 토큰검증
        } ?: throw AuthenticationException("인증실패")

        return true
    }
}

📌 WebMvcConfig

• 검증을 수행할 인터셉터를 적용하지 않을 API 엔드포인트 지정 excludePathPatterns
  이외 API로의 요청은 모두 검증 인터셉터가 동작하도록 한다.
• LoginUser 구현부 (ArgumentResolver) 등록

@Configuration
class WebMvcConfig(
    private val tokenVerifyInterceptor: TokenVerifyInterceptor,
    private val loginUserArgumentResolver: LoginUserArgumentResolver
) : WebMvcConfigurer {

    override fun addInterceptors(registry: InterceptorRegistry) {
        registry.addInterceptor(tokenVerifyInterceptor)
            .addPathPatterns("/**")
            .excludePathPatterns("/user/signup", "/user/signin")
    }

    override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
        resolvers.add(loginUserArgumentResolver)
    }
}

📌 Controller 작성

회원가입(signup), 로그인(signin), 마이페이지(me)

• /users/me로 접근하는 경우 토큰검증 인터셉터를 거치고 @LoginUser를 통해 현재 토큰을 소유한 User의 정보를 받아와서 그대로 리턴한다.

@RequestMapping("/users")
@RestController
class UserController(private val userService: UserService) {

    @PostMapping("/signup")
    fun signup(@RequestBody signupRequest: SignupRequest): ResponseEntity<String>
        = ResponseEntity.status(HttpStatus.CREATED).body(userService.saveUser(signupRequest))

    @PostMapping("/signin")
    fun signin(@RequestBody signinRequest: SigninRequest): ResponseEntity<String>
        = ResponseEntity.ok().body(userService.signin(signinRequest))

    @GetMapping("/me")
    fun me(@LoginUser user: User?): ResponseEntity<User> {
        return ResponseEntity.ok().body(user)
    }
}

📌 Junit 테스트

@Transactional
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@AutoConfigureMockMvc
@SpringBootTest
class UserTest {

    @Autowired lateinit var mockMvc: MockMvc
    @Autowired lateinit var objectMapper: ObjectMapper
    @Autowired lateinit var userRepository: UserRepository
    @Autowired lateinit var passwordEncoder: PasswordEncoder
    @Autowired lateinit var userService: UserService
    lateinit var user: User

    @BeforeAll
    fun beforeAll() {
        user = User(null, "test", passwordEncoder.encode("test"))
        userRepository.save(user)
    }


    @DisplayName("회원가입")
    @Test
    fun `회원가입 테스트` () {
        val signupRequest = SignupRequest("username", "password")

        mockMvc.post("/users/signup")
        {
            contentType = MediaType.APPLICATION_JSON
            content = objectMapper.writeValueAsString(signupRequest)
        }
            .andExpect {
                status { isCreated() }
            }
            .andDo {
                print()
            }
    }

    @DisplayName("인증 (토큰발급)")
    @Test
    fun `인증 테스트 토큰발급이 제대로 되는지` () {
        val signinRequest = SigninRequest("test", "test")

        mockMvc.post("/users/signin")
        {
            contentType = MediaType.APPLICATION_JSON
            content = objectMapper.writeValueAsString(signinRequest)
        }
            .andExpect {
                status { isOk() }
            }
            .andDo {
                print()
            }
    }

    @DisplayName("접근불가 테스트")
    @Test
    fun `토큰없이 인증을 필요로하는 API에 접근 테스트`() {
        try {
            mockMvc.get("/users/me")
                .andDo {
                    print()
                }
                .andExpect {
                    status {
                        is5xxServerError()
                    }
                }
        } catch (e: Exception) {
            println(e)
        }
    }

    @DisplayName("토큰인증 테스트")
    @Test
    fun `발급된 토큰을 이용한 인증 테스트` () {
        val signinRequest = SigninRequest("test", "test")
        val token = userService.signin(signinRequest)

        mockMvc.get("/users/me")
        {
            header("Authorization", "Bearer " + token)
        }
            .andDo {
                print()
            }
            .andExpect {
                status { isOk() }
            }
    }
}