스프링부트 게시판 API 만들기 (6) - JWT를 이용한 인증 (2) - 로그인 후 JWT 발급하기, JWT로 인증하기

 

 

 

 

 

 

 

이제 이전에 생성한 JwtService를 가지고 로그인 후 JWT를 발급하는 코드를 작성해보도록 하겠습니다.

이후 JWT만으로 인증을 하는 코드도 작성하도록 하겠습니다.

 

• 시큐리티를 이용한 JSON 데이터로 로그인 (완료)
• JWT를 이용한 인증 (진행 중)
• 도메인, 테이블 설계, 엔티티 생성
• 댓글 삭제 로직 구현
• 회원가입 + 정보수정 등 회원 서비스 구현
• 게시판 서비스 구현
• 댓글 서비스 구현 (1댓글 -> *(무한) 대댓글 구조)
• 예외 처리
• 예외 메세지 국제화
• 카테고리별 게시판 분류
• 게시글 페이징
• 동적인 검색 조건을 사용한 검색
• 사용자 간 쪽지 기능
• 무한 쪽지 스크롤
• 게시물 & 댓글에 대한 알람
• 쪽지에 대한 알람
• 접속한 사용자 간 실시간 채팅
• 회원가입 시 검증(예: XX대학교 XX과가 아니면 가입할 수 없게)
• Swagger를 사용한 API 문서 만들기
• 신고 & 블랙리스트 기능
• AOP를 통한 로그
• 어드민 페이지
• 캐시
• 배포 (+ 무중단 배포)
• 배포 자동화
• 포트와 어댑터 설계를 따르는 패키지 구조 설계하기
• ...

 

 

 

 

 

 

 

 

 

 

 

시작하기 전에 JwtService를 조금 바꾸고 가겠습니다.

 

저도 완성하고 포스팅을 쓴는게 아니라 포스팅하며 구현중이기 때문에 코드에 계속 변경사항이 있는 것에 대해 양해 부탁드립니다.

 

 

 

 

 

 

 

 

JwtService 변경

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Optional;

public interface JwtService {


    String createAccessToken(String username);
    String createRefreshToken();

    void updateRefreshToken(String username, String refreshToken);

    void destroyRefreshToken(String username);


    void sendAccessAndRefreshToken(HttpServletResponse response, String accessToken, String refreshToken);
    void sendAccessToken(HttpServletResponse response, String accessToken);


    Optional<String> extractAccessToken(HttpServletRequest request);

    Optional<String> extractRefreshToken(HttpServletRequest request);

    Optional<String> extractUsername(String accessToken);



    void setAccessTokenHeader(HttpServletResponse response, String accessToken);
    void setRefreshTokenHeader(HttpServletResponse response, String refreshToken);

    boolean isTokenValid(String token);
}

 

 

1. sendToken을 sendAccessAndRefreshToken과 sendAccessToken으로 변경하였습니다.

 

AccessToken과 RefreshToken, Username을 Optional로 반환하도록 하였고, 예외를 모두 제거하였습니다.

 

 

2. isTokenValid 가 추가되었습니다.

사실 작명에서 조금 고민했습니다. jwtService인데, isValid만 해도 되지 않을까??? 하고 말이죠..

맘대로 하세요! 저도 언제 바꿀지 모릅니다!

토큰의 유효성 검사를 할 때 사용합니다.

 

 

3. extractRefreshToken 과 extractAccessToken의 로직이 수정되었습니다.

기존 로직은 Bearer가 붙어있지 않아도 작동합니다. 이를 바꾸었습니다.

 

 

 

 

 

 

 

 

 

JwtServiceImpl 변경

package boardexample.myboard.global.jwt.service;

import boardexample.myboard.domain.member.repository.MemberRepository;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

@Transactional
@Service
@RequiredArgsConstructor
@Setter(value = AccessLevel.PRIVATE)
@Slf4j
public class JwtServiceImpl implements JwtService{

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.expiration}")
    private long accessTokenValidityInSeconds;
    @Value("${jwt.refresh.expiration}")
    private long refreshTokenValidityInSeconds;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;




    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
    private static final String USERNAME_CLAIM = "username";
    private static final String BEARER = "Bearer ";


    private final MemberRepository memberRepository;




    @Override
    public String createAccessToken(String username) {
        return JWT.create()
                .withSubject(ACCESS_TOKEN_SUBJECT)
                .withExpiresAt(new Date(System.currentTimeMillis() + accessTokenValidityInSeconds * 1000))
                .withClaim(USERNAME_CLAIM, username)
                .sign(Algorithm.HMAC512(secret));
    }

    @Override
    public String createRefreshToken() {
        return JWT.create()
                .withSubject(REFRESH_TOKEN_SUBJECT)
                .withExpiresAt(new Date(System.currentTimeMillis() + refreshTokenValidityInSeconds * 1000))
                .sign(Algorithm.HMAC512(secret));
    }

    @Override
    public void updateRefreshToken(String username, String refreshToken) {
        memberRepository.findByUsername(username)
                .ifPresentOrElse(
                        member -> member.updateRefreshToken(refreshToken),
                        () -> new Exception("회원이 없습니다")
                        );
    }



    @Override
    public void destroyRefreshToken(String username) {
        memberRepository.findByUsername(username)
                .ifPresentOrElse(
                        member -> member.destroyRefreshToken(),
                        () -> new Exception("회원이 없습니다")
                );
    }

    @Override
    public void sendAccessAndRefreshToken(HttpServletResponse response, String accessToken, String refreshToken){
        response.setStatus(HttpServletResponse.SC_OK);

        setAccessTokenHeader(response, accessToken);
        setRefreshTokenHeader(response, refreshToken);


        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(ACCESS_TOKEN_SUBJECT, accessToken);
        tokenMap.put(REFRESH_TOKEN_SUBJECT, refreshToken);

    }

    @Override
    public void sendAccessToken(HttpServletResponse response, String accessToken){
        response.setStatus(HttpServletResponse.SC_OK);

        setAccessTokenHeader(response, accessToken);


        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(ACCESS_TOKEN_SUBJECT, accessToken);
    }



    @Override
    public Optional<String> extractAccessToken(HttpServletRequest request) {
        return Optional.ofNullable(request.getHeader(accessHeader)).filter(

                accessToken -> accessToken.startsWith(BEARER)

        ).map(accessToken -> accessToken.replace(BEARER, ""));
    }

    @Override
    public Optional<String> extractRefreshToken(HttpServletRequest request) {
        return Optional.ofNullable(request.getHeader(refreshHeader)).filter(
                
                refreshToken -> refreshToken.startsWith(BEARER)
                
                ).map(refreshToken -> refreshToken.replace(BEARER, ""));
    }

    @Override
    public Optional<String> extractUsername(String accessToken) {
        try {
            return Optional.ofNullable(JWT.require(Algorithm.HMAC512(secret)).build().verify(accessToken).getClaim(USERNAME_CLAIM).asString());
        }catch (Exception e){
            log.error(e.getMessage());
            return Optional.empty();
        }
    }

    @Override
    public void setAccessTokenHeader(HttpServletResponse response, String accessToken) {
        response.setHeader(accessHeader, accessToken);
    }

    @Override
    public void setRefreshTokenHeader(HttpServletResponse response, String refreshToken) {
        response.setHeader(refreshHeader, refreshToken);
    }
    @Override
    public boolean isTokenValid(String token){
        try {
            JWT.require(Algorithm.HMAC512(secret)).build().verify(token);
            return true;
        }catch (Exception e){
            log.error("유효하지 않은 Token입니다", e.getMessage());
            return false;
        }
    }

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

JwtService 테스트코드 재작성

이를 바탕으로 다시 작성한 테스트코드를 다시 작성하겠습니다.

 

 

 

1. sendToken -> sendAccessAndRefreshToken 으로 바꿔줍니다.

 

 

 

 

2. username, accessToken, refreshToken을 반환하는 코드는 아래와 비슷하게 바꿔주면 됩니다.

jwtService.extractAccessToken(httpServletRequest);

jwtService.extractAccessToken(httpServletRequest).orElseThrow(()-> new Exception("토큰이 없습니다"));

 

 

 

 

3. 이제 jwtService에서 json으로 Body에 토큰을 넣어주지 않습니다.

 

sendAccessAndRefreshToken_토큰_전송에서 아래 코드가 사라집니다.

/*Map<String, String> tokenMap = objectMapper.readValue(mockHttpServletResponse.getContentAsString(), Map.class);
String bodyAccessToken = tokenMap.get(ACCESS_TOKEN_SUBJECT);
String bodyRefreshToken = tokenMap.get(REFRESH_TOKEN_SUBJECT);*/

 

 

 

 

4.  토큰의 유효성을 검사하는 테스트가 추가되었습니다.

@Test
public void 토큰_유효성_검사() throws Exception {
    //given
    String accessToken = jwtService.createAccessToken(username);
    String refreshToken = jwtService.createRefreshToken();

    //when, then
    assertThat(jwtService.isTokenValid(accessToken)).isTrue();
    assertThat(jwtService.isTokenValid(refreshToken)).isTrue();
    assertThat(jwtService.isTokenValid(accessToken+"d")).isFalse();
    assertThat(jwtService.isTokenValid(accessToken+"d")).isFalse();

}

 

 

 

 

 

 

 

 

 

전체 테스트 코드

import boardexample.myboard.domain.member.Member;
import boardexample.myboard.domain.member.repository.MemberRepository;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;


@SpringBootTest
@Transactional
class JwtServiceTest {



    @Autowired JwtService jwtService;
    @Autowired MemberRepository memberRepository;
    @Autowired EntityManager em;

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;

    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
    private static final String USERNAME_CLAIM = "username";
    private static final String BEARER = "Bearer ";


    private String username = "username";

    @BeforeEach
    public void init(){

        Member member = Member.builder().username(username).password("1234567890").name("Member1").nickName("NickName1").age(22).build();
        memberRepository.save(member);
        clear();
    }

    private void clear(){
        em.flush();
        em.clear();
    }


    @Test
    public void createAccessToken_AccessToken_발급() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);

        DecodedJWT verify = JWT.require(Algorithm.HMAC512(secret)).build().verify(accessToken);
        String subject = verify.getSubject();
        String findUsername = verify.getClaim(USERNAME_CLAIM).asString();

        assertThat(findUsername).isEqualTo(username);
        assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
    }

    @Test
    public void createRefreshToken_RefreshToken_발급() throws Exception {
        //given
        String refreshToken = jwtService.createRefreshToken();
        DecodedJWT verify = JWT.require(Algorithm.HMAC512(secret)).build().verify(refreshToken);
        String subject = verify.getSubject();
        String username = verify.getClaim(USERNAME_CLAIM).asString();
        assertThat(subject).isEqualTo(REFRESH_TOKEN_SUBJECT);
        assertThat(username).isNull();
    }

    @Test
    public void updateRefreshToken_refreshToken_업데이트() throws Exception {
        //given
        String refreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, refreshToken);
        clear();
        Thread.sleep(3000);

        //when
        String reIssuedRefreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, reIssuedRefreshToken);
        clear();

        //then
        assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());//
        assertThat(memberRepository.findByRefreshToken(reIssuedRefreshToken).get().getUsername()).isEqualTo(username);
    }



    @Test
    public void destroyRefreshToken_refreshToken_제거() throws Exception {
        //given
        String refreshToken = jwtService.createRefreshToken();
        jwtService.updateRefreshToken(username, refreshToken);
        clear();

        //when
        jwtService.destroyRefreshToken(username);
        clear();

        //then
        assertThrows(Exception.class, () -> memberRepository.findByRefreshToken(refreshToken).get());

        Member member = memberRepository.findByUsername(username).get();
        assertThat(member.getRefreshToken()).isNull();
    }
    @Test
    public void 토큰_유효성_검사() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        //when, then
        assertThat(jwtService.isTokenValid(accessToken)).isTrue();
        assertThat(jwtService.isTokenValid(refreshToken)).isTrue();
        assertThat(jwtService.isTokenValid(accessToken+"d")).isFalse();
        assertThat(jwtService.isTokenValid(accessToken+"d")).isFalse();

    }


    @Test
    public void setAccessTokenHeader_AccessToken_헤더_설정() throws Exception {
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        jwtService.setAccessTokenHeader(mockHttpServletResponse, accessToken);


        //when
        jwtService.sendAccessAndRefreshToken(mockHttpServletResponse,accessToken,refreshToken);

        //then
        String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);

        assertThat(headerAccessToken).isEqualTo(accessToken);
    }

    @Test
    public void setRefreshTokenHeader_RefreshToken_헤더_설정() throws Exception {
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        jwtService.setRefreshTokenHeader(mockHttpServletResponse, refreshToken);


        //when
        jwtService.sendAccessAndRefreshToken(mockHttpServletResponse,accessToken,refreshToken);

        //then
        String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

        assertThat(headerRefreshToken).isEqualTo(refreshToken);
    }





    @Test
    public void sendAccessAndRefreshToken_토큰_전송() throws Exception {
        //given
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();


        //when
        jwtService.sendAccessAndRefreshToken(mockHttpServletResponse,accessToken,refreshToken);


        //then
        String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
        String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);



        assertThat(headerAccessToken).isEqualTo(accessToken);
        assertThat(headerRefreshToken).isEqualTo(refreshToken);

    }


    @Test
    public void extractAccessToken_AccessToken_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

        //when
        String extractAccessToken = jwtService.extractAccessToken(httpServletRequest).orElseThrow(()-> new Exception("토큰이 없습니다"));


        //then
        assertThat(extractAccessToken).isEqualTo(accessToken);
        assertThat(JWT.require(Algorithm.HMAC512(secret)).build().verify(extractAccessToken).getClaim(USERNAME_CLAIM).asString()).isEqualTo(username);
    }


    @Test
    public void extractRefreshToken_RefreshToken_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);


        //when
        String extractRefreshToken = jwtService.extractRefreshToken(httpServletRequest).orElseThrow(()-> new Exception("토큰이 없습니다"));


        //then
        assertThat(extractRefreshToken).isEqualTo(refreshToken);
        assertThat(JWT.require(Algorithm.HMAC512(secret)).build().verify(extractRefreshToken).getSubject()).isEqualTo(REFRESH_TOKEN_SUBJECT);
    }


    private HttpServletRequest setRequest(String accessToken, String refreshToken) throws IOException {

        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

        jwtService.sendAccessAndRefreshToken(mockHttpServletResponse,accessToken,refreshToken);

        String headerAccessToken = mockHttpServletResponse.getHeader(accessHeader);
        String headerRefreshToken = mockHttpServletResponse.getHeader(refreshHeader);

        MockHttpServletRequest httpServletRequest = new MockHttpServletRequest();

        httpServletRequest.addHeader(accessHeader, BEARER+headerAccessToken);
        httpServletRequest.addHeader(refreshHeader, BEARER+headerRefreshToken);

        return httpServletRequest;
    }


    @Test
    public void extractUsername_Username_추출() throws Exception {
        //given
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();
        HttpServletRequest httpServletRequest = setRequest(accessToken, refreshToken);

        String requestAccessToken = jwtService.extractAccessToken(httpServletRequest).orElseThrow(()->new Exception("토큰이 없습니다"));

        //when
        String extractUsername = jwtService.extractUsername(requestAccessToken).orElseThrow(()->new Exception("토큰이 없습니다"));


        //then
        assertThat(extractUsername).isEqualTo(username);
    }




}

 

모든 테스트가 성공적으로 통과됩니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

LoginSuccessJWTProvideHandler 수정 - JWT 발급

 

이제 로그인 성공 시 JWT를 제공하는 코드를 작성하겠습니다.

 

저희는 LoginSuccessJWTProvideHandler를 통해 로그인 성공 시 후처리를 할 수 있도록 해두었습니다.

 

이제 이곳에 JWT를 발급하는 코드를 추가하겠습니다.

 

발급한 이후 회원에게 RefreshToken을 저장해주도록 하겠습니다

@Slf4j
@RequiredArgsConstructor
public class LoginSuccessJWTProvideHandler extends SimpleUrlAuthenticationSuccessHandler {

    private final JwtService jwtService;
    private final MemberRepository memberRepository;


    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {

        String username = extractUsername(authentication);
        String accessToken = jwtService.createAccessToken(username);
        String refreshToken = jwtService.createRefreshToken();

        jwtService.sendAccessAndRefreshToken(response, accessToken, refreshToken);
        
        memberRepository.findByUsername(username).ifPresent(
                member -> member.updateRefreshToken(refreshToken)
        );

        log.info( "로그인에 성공합니다. username: {}" ,username);
        log.info( "AccessToken 을 발급합니다. AccessToken: {}" ,accessToken);
        log.info( "RefreshToken 을 발급합니다. RefreshToken: {}" ,refreshToken);
    }


    private String extractUsername(Authentication authentication){
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        return userDetails.getUsername();
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

SecurityConfig 수정

SecurityConfig도 수정해주도록 하겠습니다.

 

(추가 - WebSecurityConfigurerAdapter가 Deprecate 되었습니다. 아래 사이트에 어떻게 수정해야 하는지 나와있습니다.

https://www.codejava.net/frameworks/spring-boot/fix-websecurityconfigureradapter-deprecated )

 

 

memberRepository의 종속성을 추가해줍니다.

추가로 MemberRepository와 JwtService를 필드에서 받아오도록 수정하겠습니다. 아래는 전체 코드입니다.

@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final LoginService loginService;
    private final ObjectMapper objectMapper;
    private final MemberRepository memberRepository;
    private final JwtService jwtService;



    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
                .formLogin().disable()//formLogin 인증방법 비활성화
                .httpBasic().disable()//httpBasic 인증방법 비활성화(특정 리소스에 접근할 때 username과 password 물어봄)
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

                .and()
                .authorizeRequests()
                .antMatchers("/login", "/signUp","/").permitAll()
                .anyRequest().authenticated();

        http.addFilterAfter(jsonUsernamePasswordLoginFilter(), LogoutFilter.class);
        http.addFilterBefore(jwtAuthenticationProcessingFilter(), JsonUsernamePasswordAuthenticationFilter.class);

    }

    @Bean
    public PasswordEncoder passwordEncoder(){
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager() {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setPasswordEncoder(passwordEncoder());
        provider.setUserDetailsService(loginService);
        return new ProviderManager(provider);
    }

    @Bean
    public LoginSuccessJWTProvideHandler loginSuccessJWTProvideHandler(){
        return new LoginSuccessJWTProvideHandler(jwtService, memberRepository);//변경
    }

    @Bean
    public LoginFailureHandler loginFailureHandler(){
        return new LoginFailureHandler();
    }

    @Bean
    public JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter(){
        JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter = new JsonUsernamePasswordAuthenticationFilter(objectMapper);
        jsonUsernamePasswordLoginFilter.setAuthenticationManager(authenticationManager());
        jsonUsernamePasswordLoginFilter.setAuthenticationSuccessHandler(loginSuccessJWTProvideHandler());
        jsonUsernamePasswordLoginFilter.setAuthenticationFailureHandler(loginFailureHandler());//변경
        return jsonUsernamePasswordLoginFilter;
    }

    @Bean
    public JwtAuthenticationProcessingFilter jwtAuthenticationProcessingFilter(){
        JwtAuthenticationProcessingFilter jsonUsernamePasswordLoginFilter = new JwtAuthenticationProcessingFilter(jwtService, memberRepository);

        return jsonUsernamePasswordLoginFilter;
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

AccessToken을 통한 인증 Filter 추가

 

이제 인증이 필요한 모든 요청에서 AccessToken을 통해 인증을 진행하는 코드를 작성하겠습니다.

우선 현재 상황에서 요청을 보내면 작동하는 필터들을 살펴보도록 하겠습니다.

솔직히 말해서 잘 모르겠습니다. 마음같아서는 그냥 제일 먼저 코드 넣고 싶어서 맨 첫 필터인 WebAsyncManagerIntegrationFilter 이전에 넣어버리고 싶지만.. 그래서 코드를 한번 봐보았습니다.

 

네 뭔소리인지 모르겠어서 포기했습니다.

 

이후 시큐리티의 여러 필터들을 공부하며, 적절한 필터의 위치로 옮기도록 하고, 우선은 저희가 등록했던 JsonUsernamePasswordAuthenticationFilter 이전에 등록하도록 하겠습니다.

 

 

생각해둔 요구사항은 다음과 같습니다

 

 

 

 

 

요구사항

• "/login "으로 오는 요청에 대해서는 필터를 작동시키지 않고, JsonUsernamePasswordAuthenticationFilter에게 로그인 처리를 위임합니다.
• 그 외에 들어오는 모든 요청에 대해서 작동합니다.
• RefreshToken을 포함하여 요청이 전송되는 경우는 다음 네 가지 상황이 있을 수 있습니다. 
  1. 둘 다 유효한 경우 -> AccessToken재발급, 인증은 진행하지 않음.
  2. RefreshToken은 유효하고, AccessToken은 없거나 유효하지 않은 경우 -> AccessToken 재발급
  3. RefreshToken은 없거나 유효하지 않고, AccessToken은 유효한 경우 -> 인증은 성공되나, RefreshToken을 재발급하지는 않음
  4. RefreshToken과 AccessToken 모두 없거나 유효하지 않은 경우 -> 인증에 실패합니다. 403을 제공합니다. (이후 200을 제공하되, 서버와 클라이언트간에 약속한 코드를 추가하여 어떤 에러인지 보호하여 전달하겠습니다.)

 

 

 

 

 

 

참고

잠시 3번에 대해서 말하고 넘어가겠습니다.

 

왜 RefreshToken을 재발급하지 않느냐고 물어본다면 저의 생각은 이러합니다.

RefreshToken은 매우 중요합니다.

RefreshToken을 통해 AccessToken을 재발급받을 수 있기에, 이를 탈취당하면 보안상 큰 위험이 있을 수 있습니다.

 

AccessToken은 탈취당하더라도 유효기간이 짧기때문에, 큰 피해는 막을 수 있다고 생각합니다.

그런데 AccessToken을 통해 RefreshToken을 재발급한다???

이건 좀 아닌 거 같습니다.

 

AccessToken을 탈취당하는 순간, 계속해서 RefreshToken을 발급받을 수 있기에 보안상 큰 위험이 있을거라 생각하여 저는 이렇게 설정했습니다.

 

추가로 RefreshToken은 만료되었으나 AccessToken은 아직 만료되지 않은 경우도 있다고 봅니다.

 

RefreshToken의 만료시간 10분 전에, 유효시간이 30분인 AccessToken을 발급받은 경우를 가정해본다면

10분 후에는 RefreshToken은 만료되나 AccessToken은 유효합니다. 

 

이런 상황에서는 저는 인증처리를 진행해도 괜찮다는 생각 하에 이렇게 위와같이 설정했습니다.

 

(찾아보던 중 어떤 글에서 AccessToken을 통해 RefreshToken을 재발급한다는 글을 보고, 이건 아니지 않나 싶어서 써봄니다.)

 

 

이제 구현을 시작하도록 하겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

JwtAuthenticationProcessingFilter 생성

OncePerRequestFilter를 상속받아 사용하겠습니다. 

 

OncePerRequestFilter의 설명은 다음과 같습니다.

모든 서블릿 컨테이너에서 요청 디스패치당 단일 실행을 보장하는 것을 목표로 하는 필터 기본 클래스입니다.

+ 제가 아직 필터들을 잘 모르는것도 있고, 강의를 보았는데 해당 필터를 상속받아 구현한 강의도 있었습니다.

 

 

import boardexample.myboard.domain.member.Member;
import boardexample.myboard.domain.member.repository.MemberRepository;
import boardexample.myboard.global.jwt.service.JwtService;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper;
import org.springframework.security.core.authority.mapping.NullAuthoritiesMapper;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


@RequiredArgsConstructor
public class JwtAuthenticationProcessingFilter extends OncePerRequestFilter {

    private final JwtService jwtService;
    private final MemberRepository memberRepository;

    private GrantedAuthoritiesMapper authoritiesMapper = new NullAuthoritiesMapper();//5

    private final String NO_CHECK_URL = "/login";//1

    /**
     * 1. 리프레시 토큰이 오는 경우 -> 유효하면 AccessToken 재발급후, 필터 진행 X, 바로 튕기기
     *
     * 2. 리프레시 토큰은 없고 AccessToken만 있는 경우 -> 유저정보 저장후 필터 계속 진행
     */
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if(request.getRequestURI().equals(NO_CHECK_URL)) {
            filterChain.doFilter(request, response);
            return;//안해주면 아래로 내려가서 계속 필터를 진행해버림
        }

        String refreshToken = jwtService
        		.extractRefreshToken(request)
                .filter(jwtService::isTokenValid)
                .orElse(null); //2


        if(refreshToken != null){
            checkRefreshTokenAndReIssueAccessToken(response, refreshToken);//3
            return;
        }

        checkAccessTokenAndAuthentication(request, response, filterChain);//4

    }




    private void checkAccessTokenAndAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        jwtService.extractAccessToken(request).filter(jwtService::isTokenValid).ifPresent(

                accessToken -> jwtService.extractUsername(accessToken).ifPresent(

                        username -> memberRepository.findByUsername(username).ifPresent(

                                member -> saveAuthentication(member)
                        )
                )
        );

        filterChain.doFilter(request,response);
    }



    private void saveAuthentication(Member member) {
        UserDetails user = User.builder()
                .username(member.getUsername())
                .password(member.getPassword())
                .roles(member.getRole().name())
                .build();

        Authentication authentication = new UsernamePasswordAuthenticationToken(user, null,authoritiesMapper.mapAuthorities(user.getAuthorities()));


        SecurityContext context = SecurityContextHolder.createEmptyContext();//5
        context.setAuthentication(authentication);
        SecurityContextHolder.setContext(context);
    }

    private void checkRefreshTokenAndReIssueAccessToken(HttpServletResponse response, String refreshToken) {


        memberRepository.findByRefreshToken(refreshToken).ifPresent(
                member -> jwtService.sendAccessToken(response, jwtService.createAccessToken(member.getUsername()))
        );


    }
}

1. "/login" 으로 들어오는 요청에 대해서는 작동하지 않습니다.

2. RefreshToken이 없거나 유효하지 않다면 null을 반환합니다.

3. refreshToken이 유효하다면 해당 refreshToken을 가진 유저정보를 찾아오고, 존재한다면 AccessToken을 재발급합니다.

이때 바로 return시키는데, 그 이유는 refreshToken만 보낸 경우에는 인증을 처리하지 않게 하기 위해서입니다. 

 

4. refreshToken이 없다면 AccessToken을 검사하는 로직을 수행합니다.

request에서 AccessToken을 추출한 후, 있다면 해당 AccessToken에서 username을 추출합니다.

username이 추출되었다면 해당 회원을 찾아와서 그 정보를 가지고 인증처리를 합니다.

이때 SecurityContextHolder에 Authentication 객체를 만들어 반환하는데, NullAuthoritiesMapper가 쓰입니다.

 

이는 제가 만들어 준 것이 아닌 스프링 시큐리티에서 제공해주는 것입니다.

 

 

AbstractUserDetailsAuthenticationProvider의 방식을 보고 따라해 보았습니다.

AbstractUserDetailsAuthenticationProvider에서 NullAuthoritiesMapper 사용

 

 

AbstractUserDetailsAuthenticationProvider

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

테스트코드 작성

 

기본 세팅은 다음과 같습니다.

@SpringBootTest
@AutoConfigureMockMvc
@Transactional
public class JwtFilterAuthenticationTest {

    @Autowired
    MockMvc mockMvc;

    @Autowired
    MemberRepository memberRepository;

    @Autowired
    EntityManager em;

    @Autowired
    JwtService jwtService;

    PasswordEncoder delegatingPasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();


    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;

    private static String KEY_USERNAME = "username";
    private static String KEY_PASSWORD = "password";
    private static String USERNAME = "username";
    private static String PASSWORD = "123456789";

    private static String LOGIN_RUL = "/login";


    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String BEARER = "Bearer ";


    private ObjectMapper objectMapper = new ObjectMapper();



    private void clear(){
        em.flush();
        em.clear();
    }


    @BeforeEach
    private void init(){
        memberRepository.save(Member.builder().username(USERNAME).password(delegatingPasswordEncoder.encode(PASSWORD)).name("Member1").nickName("NickName1").role(Role.USER).age(22).build());
        clear();
    }



    private Map getUsernamePasswordMap(String username, String password){
        Map<String, String> map = new HashMap<>();
        map.put(KEY_USERNAME, username);
        map.put(KEY_PASSWORD, password);
        return map;
    }


    private Map getAccessAndRefreshToken() throws Exception {

        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);

        MvcResult result = mockMvc.perform(
                         post(LOGIN_RUL)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(map)))
                .andReturn();

        String accessToken = result.getResponse().getHeader(accessHeader);
        String refreshToken = result.getResponse().getHeader(refreshHeader);

        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(accessHeader,accessToken);
        tokenMap.put(refreshHeader,refreshToken);

        return tokenMap;
    }

 

 

 

 

 

 

 

 

 

 

 

AccessToken, RefreshToken 모두 존재하지 않은 경우

    /**
     * AccessToken : 존재하지 않음,
     * RefreshToken : 존재하지 않음
     */
    @Test
    public void Access_Refresh_모두_존재_X() throws Exception {
        //when, then
        mockMvc.perform(get(LOGIN_RUL+"123"))//login이 아닌 다른 임의의 주소
                .andExpect(status().isForbidden());
    }

 

 

 

 

 

 

 

 

 

 

 

 

AccessToken만 존재하는 경우 -> 유효한 토큰일 때

/**
 * AccessToken : 유효,
 * RefreshToken : 존재하지 않음
 */
@Test
public void AccessToken만_보내서_인증() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);

    //when, then
    mockMvc.perform(get(LOGIN_RUL+"123").header(accessHeader,BEARER+ accessToken))//login이 아닌 다른 임의의 주소
            .andExpectAll(status().isNotFound());//없는 주소로 보냈으므로 NotFound

}

 

 

 

 

 

 

 

 

 

AccessToken만 존재하는 경우 -> 유효하지 않은 토큰일 때

/**
 * AccessToken : 유효하지 않음,
 * RefreshToken : 존재하지 않음
 */
@Test
public void 안유효한AccessToken만_보내서_인증X_상태코드는_403() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);

    //when, then
    mockMvc.perform(get(LOGIN_RUL+"123").header(accessHeader,accessToken+"1"))//login이 아닌 다른 임의의 주소
            .andExpectAll(status().isForbidden());//없는 주소로 보냈으므로 NotFound
}

 

 

 

 

 

 

 

 

 

 

RefreshToken만 존재하는 경우 -> 유효한 토큰일 때

/**
 * AccessToken : 존재하지 않음
 * RefreshToken : 유효
 */
@Test
public void 유효한RefreshToken만_보내서_AccessToken_재발급_200() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, BEARER+refreshToken))//login이 아닌 다른 임의의 주소
            .andExpect(status().isOk()).andReturn();

    String accessToken = result.getResponse().getHeader(accessHeader);

    String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(accessToken).getSubject();
    assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
}

 

 

 

 

 

 

 

 

 

RefreshToken만 존재하는 경우 -> 유효하지 않은 경우

/**
 * AccessToken : 존재하지 않음
 * RefreshToken : 유효하지 않음
 */
@Test
public void 안유효한RefreshToken만_보내면_403() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
     mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, refreshToken))//Bearer을 붙이지 않음
            .andExpect(status().isForbidden());

    mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, BEARER+refreshToken+"1"))//유효하지 않은 토큰
            .andExpect(status().isForbidden());
}

 

 

 

 

 

 

 

 

 

AccessToken, RefreshToken 모두 유효한 경우 - AccessToken 재발급

/**
 * AccessToken : 유효
 * RefreshToken : 유효
 */
@Test
public void 유효한RefreshToken이랑_유효한AccessToken_같이보냈을때_AccessToken_재발급_200() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                    .header(refreshHeader, BEARER + refreshToken)
                    .header(accessHeader, BEARER + accessToken))
            .andExpect(status().isOk())
            .andReturn();

    String responseAccessToken = result.getResponse().getHeader(accessHeader);
    String responseRefreshToken = result.getResponse().getHeader(refreshHeader);

    String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(responseAccessToken).getSubject();

    assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
    assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
}

 

 

 

 

 

 

 

 

 

RefreshToken은 유효하고, AccessToken은 유효하지 않은 경우 - AccessToken 재발급

/**
 * AccessToken : 유효하지 않음
 * RefreshToken : 유효
 */
@Test
public void 유효한RefreshToken이랑_안유효한AccessToken_같이보냈을때_AccessToken_재발급_200() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                    .header(refreshHeader, BEARER + refreshToken)
                    .header(accessHeader, BEARER + accessToken + 1))
            .andExpect(status().isOk())
            .andReturn();

    String responseAccessToken = result.getResponse().getHeader(accessHeader);
    String responseRefreshToken = result.getResponse().getHeader(refreshHeader);

    String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(responseAccessToken).getSubject();

    assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
    assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
}

 

 

 

 

 

 

 

 

 

 

AccessToken은 유효하고, RefreshToken은 유효하지 않은 경우 - 인증은 되나 아무것도 재발급되지 않음

/**
 * AccessToken : 유효
 * RefreshToken : 유효하지 않음
 */
@Test
public void 안유효한RefreshToken이랑_유효한AccessToken_같이보냈을때_상태코드200_혹은404_RefreshToken은_AccessToken모두_재발급되지않음() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                    .header(refreshHeader, BEARER + refreshToken+1)
                    .header(accessHeader, BEARER + accessToken ))
            .andExpect(status().isNotFound())//없는 주소로 보냈으므로 NotFound
            .andReturn();

    String responseAccessToken = result.getResponse().getHeader(accessHeader);
    String responseRefreshToken = result.getResponse().getHeader(refreshHeader);


    assertThat(responseAccessToken).isNull();//accessToken은 재발급되지 않음
    assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
}

 

 

 

 

 

 

 

 

 

AccessToken, RefreshToken 모두 유효하지 않은 경우

/**
 * AccessToken : 유효하지 않음
 * RefreshToken : 유효하지 않음
 */
@Test
public void 안유효한RefreshToken이랑_안유효한AccessToken_같이보냈을때_403() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                    .header(refreshHeader, BEARER + refreshToken+1)
                    .header(accessHeader, BEARER + accessToken+1 ))
            .andExpect(status().isForbidden())//없는 주소로 보냈으므로 NotFound
            .andReturn();

    String responseAccessToken = result.getResponse().getHeader(accessHeader);
    String responseRefreshToken = result.getResponse().getHeader(refreshHeader);


    assertThat(responseAccessToken).isNull();//accessToken은 재발급되지 않음
    assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음

}

 

 

 

 

 

 

 

 

 

로그인 주소로 보내면 필터 작동 X

@Test
public void 로그인_주소로_보내면_필터작동_X() throws Exception {
    //given
    Map accessAndRefreshToken = getAccessAndRefreshToken();
    String accessToken= (String) accessAndRefreshToken.get(accessHeader);
    String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

    //when, then
    MvcResult result = mockMvc.perform(post(LOGIN_RUL)  //get인 경우 config에서 permitAll을 했기에 notFound
                    .header(refreshHeader, BEARER + refreshToken)
                    .header(accessHeader, BEARER + accessToken))
            .andExpect(status().isOk())
            .andReturn();

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

전체 테스트코드

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
@Transactional
public class JwtFilterAuthenticationTest {

    @Autowired
    MockMvc mockMvc;

    @Autowired
    MemberRepository memberRepository;

    @Autowired
    EntityManager em;

    @Autowired
    JwtService jwtService;

    PasswordEncoder delegatingPasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();


    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.access.header}")
    private String accessHeader;
    @Value("${jwt.refresh.header}")
    private String refreshHeader;

    private static String KEY_USERNAME = "username";
    private static String KEY_PASSWORD = "password";
    private static String USERNAME = "username";
    private static String PASSWORD = "123456789";

    private static String LOGIN_RUL = "/login";


    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String BEARER = "Bearer ";


    private ObjectMapper objectMapper = new ObjectMapper();



    private void clear(){
        em.flush();
        em.clear();
    }


    @BeforeEach
    private void init(){
        memberRepository.save(Member.builder().username(USERNAME).password(delegatingPasswordEncoder.encode(PASSWORD)).name("Member1").nickName("NickName1").role(Role.USER).age(22).build());
        clear();
    }



    private Map getUsernamePasswordMap(String username, String password){
        Map<String, String> map = new HashMap<>();
        map.put(KEY_USERNAME, username);
        map.put(KEY_PASSWORD, password);
        return map;
    }


    private Map getAccessAndRefreshToken() throws Exception {

        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);

        MvcResult result = mockMvc.perform(
                         post(LOGIN_RUL)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(map)))
                .andReturn();

        String accessToken = result.getResponse().getHeader(accessHeader);
        String refreshToken = result.getResponse().getHeader(refreshHeader);

        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(accessHeader,accessToken);
        tokenMap.put(refreshHeader,refreshToken);

        return tokenMap;
    }






    /**
     * AccessToken : 존재하지 않음,
     * RefreshToken : 존재하지 않음
     */
    @Test
    public void Access_Refresh_모두_존재_X() throws Exception {
        //when, then
        mockMvc.perform(get(LOGIN_RUL+"123"))//login이 아닌 다른 임의의 주소
                .andExpect(status().isForbidden());
    }



    /**
     * AccessToken : 유효,
     * RefreshToken : 존재하지 않음
     */
    @Test
    public void AccessToken만_보내서_인증() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);

        //when, then
        mockMvc.perform(get(LOGIN_RUL+"123").header(accessHeader,BEARER+ accessToken))//login이 아닌 다른 임의의 주소
                .andExpectAll(status().isNotFound());//없는 주소로 보냈으므로 NotFound

    }


    /**
     * AccessToken : 유효하지 않음,
     * RefreshToken : 존재하지 않음
     */
    @Test
    public void 안유효한AccessToken만_보내서_인증X_상태코드는_403() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);

        //when, then
        mockMvc.perform(get(LOGIN_RUL+"123").header(accessHeader,accessToken+"1"))//login이 아닌 다른 임의의 주소
                .andExpectAll(status().isForbidden());//없는 주소로 보냈으므로 NotFound
    }


    /**
     * AccessToken : 존재하지 않음
     * RefreshToken : 유효
     */
    @Test
    public void 유효한RefreshToken만_보내서_AccessToken_재발급_200() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, BEARER+refreshToken))//login이 아닌 다른 임의의 주소
                .andExpect(status().isOk()).andReturn();

        String accessToken = result.getResponse().getHeader(accessHeader);

        String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(accessToken).getSubject();
        assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
    }



    /**
     * AccessToken : 존재하지 않음
     * RefreshToken : 유효하지 않음
     */
    @Test
    public void 안유효한RefreshToken만_보내면_403() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
         mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, refreshToken))//Bearer을 붙이지 않음
                .andExpect(status().isForbidden());

        mockMvc.perform(get(LOGIN_RUL + "123").header(refreshHeader, BEARER+refreshToken+"1"))//유효하지 않은 토큰
                .andExpect(status().isForbidden());
    }



    /**
     * AccessToken : 유효
     * RefreshToken : 유효
     */
    @Test
    public void 유효한RefreshToken이랑_유효한AccessToken_같이보냈을때_AccessToken_재발급_200() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                        .header(refreshHeader, BEARER + refreshToken)
                        .header(accessHeader, BEARER + accessToken))
                .andExpect(status().isOk())
                .andReturn();

        String responseAccessToken = result.getResponse().getHeader(accessHeader);
        String responseRefreshToken = result.getResponse().getHeader(refreshHeader);

        String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(responseAccessToken).getSubject();

        assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
        assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
    }





    /**
     * AccessToken : 유효하지 않음
     * RefreshToken : 유효
     */
    @Test
    public void 유효한RefreshToken이랑_안유효한AccessToken_같이보냈을때_AccessToken_재발급_200() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                        .header(refreshHeader, BEARER + refreshToken)
                        .header(accessHeader, BEARER + accessToken + 1))
                .andExpect(status().isOk())
                .andReturn();

        String responseAccessToken = result.getResponse().getHeader(accessHeader);
        String responseRefreshToken = result.getResponse().getHeader(refreshHeader);

        String subject = JWT.require(Algorithm.HMAC512(secret)).build().verify(responseAccessToken).getSubject();

        assertThat(subject).isEqualTo(ACCESS_TOKEN_SUBJECT);
        assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
    }


    /**
     * AccessToken : 유효
     * RefreshToken : 유효하지 않음
     */
    @Test
    public void 안유효한RefreshToken이랑_유효한AccessToken_같이보냈을때_상태코드200_혹은404_RefreshToken은_AccessToken모두_재발급되지않음() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                        .header(refreshHeader, BEARER + refreshToken+1)
                        .header(accessHeader, BEARER + accessToken ))
                .andExpect(status().isNotFound())//없는 주소로 보냈으므로 NotFound
                .andReturn();

        String responseAccessToken = result.getResponse().getHeader(accessHeader);
        String responseRefreshToken = result.getResponse().getHeader(refreshHeader);


        assertThat(responseAccessToken).isNull();//accessToken은 재발급되지 않음
        assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음
    }



    /**
     * AccessToken : 유효하지 않음
     * RefreshToken : 유효하지 않음
     */
    @Test
    public void 안유효한RefreshToken이랑_안유효한AccessToken_같이보냈을때_403() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(get(LOGIN_RUL + "123")
                        .header(refreshHeader, BEARER + refreshToken+1)
                        .header(accessHeader, BEARER + accessToken+1 ))
                .andExpect(status().isForbidden())//없는 주소로 보냈으므로 NotFound
                .andReturn();

        String responseAccessToken = result.getResponse().getHeader(accessHeader);
        String responseRefreshToken = result.getResponse().getHeader(refreshHeader);


        assertThat(responseAccessToken).isNull();//accessToken은 재발급되지 않음
        assertThat(responseRefreshToken).isNull();//refreshToken은 재발급되지 않음

    }

    @Test
    public void 로그인_주소로_보내면_필터작동_X() throws Exception {
        //given
        Map accessAndRefreshToken = getAccessAndRefreshToken();
        String accessToken= (String) accessAndRefreshToken.get(accessHeader);
        String refreshToken= (String) accessAndRefreshToken.get(refreshHeader);

        //when, then
        MvcResult result = mockMvc.perform(post(LOGIN_RUL)  //get인 경우 config에서 permitAll을 했기에 notFound
                        .header(refreshHeader, BEARER + refreshToken)
                        .header(accessHeader, BEARER + accessToken))
                .andExpect(status().isBadRequest())
                .andReturn();

    }



}

 

 

 

 

 

 

 

 

 

 

전체 코드는 깃허브에서 확인하실 수 있습니다.

 

https://github.com/ShinDongHun1/SpringBoot-Board-API

GitHub - ShinDongHun1/SpringBoot-Board-API