🔥 TIL - Day 72 Kotlin & Springboot 03 Spring Security 적용하기 (Jwt방식 인증)

전체소스 Github

Spring Security보다는 Kotlin을 이용해보는 것이 목적이므로 굉장히 간단하게 구현했다.
(권한 없음)

📌 Entity

data 클래스는 엔티티 클래스에 적합하지 않다고 판단되어 사용하지 않았고 setter의 경우 접근을 막고 비즈니스 로직을 반영한 메서드를 정의했다.

@Entity
@Table(name = "MEMBRE_TBL")
class Member (
    username: String,
    password: String,
    ) : Timestamped() {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long? = null

    @Column(nullable = false, unique = true)
    var username: String = username
        protected set // setter 접근금지 (비즈니스 로직을 반영 => updateUsername)

    @Column(nullable = false)
    var password: String = password
        protected set

    @OneToMany(mappedBy = "member")
    val boards: MutableList<Board> = ArrayList()

    fun updateMember(memberDto: MemberDto) {
        this.username = memberDto.username
        this.password = memberDto.password
    }
    
    fun updateUsername(username: String) {
        this.username = username
    }

    fun updatePassword(password: String) {
        this.password = password
    }
}

---

📌 Repository

이후 SpringSecurity의 UserDetailsService에서 사용하기 위해 username으로 조회하는 쿼리만 하나 정의한다.

interface MemberRepository : JpaRepository<Member, Long> {
    fun findByUsername(username: String) : Member?
}

---

📌 WebSecurityConfig (SpringSecurity 설정파일 정의)

• post, delete 등 요청을 테스트해보기 위해 csrf는 disable 처리한다.
• signup(회원가입), signin(인증) 만 접근을 허용하고 다른 API 및 리소스는 모두 인증을 필요로 하도록 설정한다.
• 토큰방식 인증을 사용하므로 session은 STATELESS 로 설정한다.
• jwt토큰을 수행하는 JwtFilter를 만들고 UsernamePasswordAuthenticationFilter 이전에 배치하여 먼저 인증을 수행하도록 처리한다.
• authenticationManagerBean 로 AuthenticationManager를 주입받아서 Jwt토큰이 유효한 경우 임으로 인증되지 않은 AuthenticationToken에 대해 인증처리를 수행한다.

@Configuration
@EnableWebSecurity
class WebSecurityConfig(
    private val userDetailsService: UserDetailsServiceImpl,
    private val jwtFilter: JwtFilter
    ) : WebSecurityConfigurerAdapter() {

    override fun configure(http: HttpSecurity) {

        http.csrf().disable()

        http.authorizeRequests()
            .antMatchers("/api/members/signup", "/api/members/signin").permitAll()
            .anyRequest().authenticated()
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter::class.java)
    }

    @Bean
    fun passwordEncoder() = BCryptPasswordEncoder()

    @Bean
    override fun authenticationManagerBean(): AuthenticationManager {
        return super.authenticationManagerBean()
    }
}

---

📌 UserDetails & UserDetailsService 커스텀

SpringSecurity가 관리하는 principal 객체인 UserDetails 를 우리의 Member가 되도록 커스텀하고 UserDetailsService 또한 Member 타입을 인증하도록 하기 위함이다.

UserDetails

UserDetails를 구현하고 Member 엔티티를 생성자로 받아서 Member의 정보를 관리하도록 한다.
여기서 Member는 UserDetailsService에서 검증(DB조회) 후에 넘어오는 객체이다.

class UserDetailsImpl(val member: Member) : UserDetails {

    var enabled: Boolean = true

    override fun getAuthorities(): MutableCollection<out GrantedAuthority> = AuthorityUtils.createAuthorityList()

    override fun getPassword(): String = member.password

    override fun getUsername(): String = member.password

    override fun isAccountNonExpired(): Boolean = enabled

    override fun isAccountNonLocked(): Boolean = enabled

    override fun isCredentialsNonExpired(): Boolean = enabled

    override fun isEnabled(): Boolean = enabled
}

UserDetailsService

MemberRepository를 DI받아 username에 대한 검증(DB조회)을 수행하고 그 결과를 UserDetails로 넘겨준다.

@Service
class UserDetailsServiceImpl(private val memberRepository: MemberRepository) : UserDetailsService {

    override fun loadUserByUsername(username: String): UserDetails {
        val member: Member = memberRepository.findByUsername(username) ?: throw UsernameNotFoundException("존재하지 않는 username 입니다.")

        return UserDetailsImpl(member)
    }
}

---

📌 JwtUtils 클래스 (Jwt 생성 및 검증을 위한 유틸 클래스)

@Component
class JwtUtils(private val userDetailsService: UserDetailsServiceImpl) {

    val EXP_TIME: Long = 1000L * 60 * 3
    val JWT_SECRET: String = "secret"
    val SIGNATURE_ALG: SignatureAlgorithm = SignatureAlgorithm.HS256

    // 토큰생성
    fun createToken(username: String): String {
        val claims: Claims = Jwts.claims();
        claims["username"] = username

        return Jwts.builder()
            .setClaims(claims)
            .setExpiration(Date(System.currentTimeMillis()+ EXP_TIME))
            .signWith(SIGNATURE_ALG, JWT_SECRET)
            .compact()
    }
	
    // 토큰검증
    fun validation(token: String) : Boolean {
        val claims: Claims = getAllClaims(token)
        val exp: Date = claims.expiration
        return exp.after(Date())
    }
    
    // 토큰에서 username 파싱
    fun parseUsername(token: String): String {
        val claims: Claims = getAllClaims(token)
        return claims["username"] as String
    }
    
    // username으로 Authentcation객체 생성
    fun getAuthentication(username: String): Authentication {
        val userDetails: UserDetails = userDetailsService.loadUserByUsername(username)

        return UsernamePasswordAuthenticationToken(userDetails, null, userDetails.authorities)
    }
    
    
    // 모든 Claims 조회
    private fun getAllClaims(token: String): Claims {
        return Jwts.parser()
            .setSigningKey(JWT_SECRET)
            .parseClaimsJws(token)
            .body
    }
}

---

📌 Jwt 검증필터 구현

@Component
class JwtFilter(private val jwtUtils: JwtUtils) : OncePerRequestFilter() {

    override fun doFilterInternal(
        request: HttpServletRequest,
        response: HttpServletResponse,
        filterChain: FilterChain
    ) {
        // 헤더에 Authorization이 있다면 가져온다.
        val authorizationHeader: String? = request.getHeader("Authorization") ?: return filterChain.doFilter(request, response)
        // Bearer타입 토큰이 있을 때 가져온다.
        val token = authorizationHeader?.substring("Bearer ".length) ?: return filterChain.doFilter(request, response)

        // 토큰 검증
        if (jwtUtils.validation(token)) {
            // 토큰에서 username 파싱
            val username = jwtUtils.parseUsername(token)
            // username으로 AuthenticationToken 생성
            val authentication: Authentication = jwtUtils.getAuthentication(username)
            // 생성된 AuthenticationToken을 SecurityContext가 관리하도록 설정
            SecurityContextHolder.getContext().authentication = authentication
        }

        filterChain.doFilter(request, response)
    }
}

---

📌 Service 계층 구현 (로그인 처리)

토큰이 없는 상태로 최초 로그인을 하게 되면 username과 password를 들고 들어올 것이다.
클라이언트로부터 받은 username과 password로 인증을 시도하고 인증에 성공했다면 토큰을 생성하여 클라이언트에게 응답한다.

@Service
class MemberService(
    private val memberRepository: MemberRepository,
    private val passwordEncoder: PasswordEncoder,
    private val authenticationManager: AuthenticationManager,
    private val jwtUtils: JwtUtils
) {

    @Transactional(readOnly = true)
    fun signin(memberDto: MemberDto): String {
        try {
            // 인증시도
            authenticationManager.authenticate(
                UsernamePasswordAuthenticationToken(memberDto.username, memberDto.password, null)
            )
        } catch (e: BadCredentialsException) {
            throw BadCredentialsException("로그인 실패")
        }
        // 예외가 발생하지 않았다면 인증에 성공한 것. 
        // 토큰 생성
        val token = jwtUtils.createToken(memberDto.username)
       
        return token
    }
}

---

📌 Controller 계층 구현

인증정보(username, password)를 받아 service계층의 인증로직을 수행하고 예외없이 리턴되면 클라이언트에게 응답으로 내려준다.

@RequestMapping("/api/members")
@RestController
class MemberController(private val memberService: MemberService ) {

    @PostMapping("/signin")
    fun signin(@RequestBody memberDto: MemberDto) = ResponseEntity.ok().body(memberService.signin(memberDto))

}

---

📌 테스트

@Transactional
@AutoConfigureMockMvc
@SpringBootTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS) // BeforeAll
class MemberApiControllerTest {

    @Test
    @DisplayName("로그인 테스트")
    fun `로그인 테스트 jwt 토큰발급 테스트` () {

        val signinDto: SigninDto = SigninDto("test", "test")
        val signinDtoJson = objectMapper.writeValueAsString(signinDto)

        mockMvc.post("/api/members/signin")
        {
            contentType = MediaType.APPLICATION_JSON
            content = signinDtoJson
        }
            .andExpect {
                status { isOk() }
            }
            .andDo {
                print()
            }
    }
}

Postman 테스트