Kakao OAuth2 + JWT + Redis를 통한 인증 과정 구현 (2) - JWT 적용

지난 포스팅에서 카카오 로그인과 그 후처리 과정들을 구현하면서 loadUser() 메소드에서

• 최초 로그인의 경우 데이터베이스에 회원을 저장하고, Details 객체를 만들어 Authentication 객체에 담고, SecurityContext에 Authentication 객체를 보관하도록 설정하였고
• 최초 로그인이 아닌 경우에는 데이터베이스에서 회원을 가져와 Details 객체를 만들어 Authentication 객체에 담고, SecurityContext에 Authentication 객체를 보관하도록 설정하였습니다.

이번 포스팅에서는 JWT를 프로젝트에 어떻게 적용했는지 코드를 살펴보겠습니다.

 

* 이번 포스팅에서는 단순 JWT 적용에 대해서 알아보고, accessToken 만료에 대한 처리 과정은 다음 포스팅에 기록하겠습니다!

 

JWT가 어떤 인증 방식인지는 아래 포스팅을 참고해주세요.

[Security] JWT(Json Web Token) 인증 방식

---

0. 설정 정보 

application.yml

jwt:
  secret_key: ${jwt.secret_key}
  access-token-validity-in-seconds: 30000 # (배포 시 30분 -> 1800 설정)
  refresh-token-validity-in-seconds: 86400 # (배포 시 1일 -> 86400설정)

 

시그니처에 사용할 시크릿 키와, 액세스 토큰 만료시간, 리프레시 토큰 만료 시간을 yml에 지정해주었습니다. 시크릿 키 값은 중요한 정보이니만큼 github로 형상관리하지 않고, 별도로 다른 파일에 설정해주고 해당 파일은 gitignore에 등록해주었습니다.

 

build.gradle에 의존성 추가

implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'

 

---

1. TokenProvider - 사용자 정보로 JWT 토큰 생성

@Component
public class TokenProvider {

    private static final String AUTH_KEY = "AUTHORITY";
    private static final String AUTH_EMAIL = "EMAIL";

    private final String secretKey;
    private final long accessTokenValidityMilliSeconds;
    private final long refreshTokenValidityMilliSeconds;

    private Key secretkey;

    public TokenProvider(@Value("${jwt.secret_key}") String secretKey,
                         @Value("${jwt.access-token-validity-in-seconds}") long accessTokenValiditySeconds,
                         @Value("${jwt.refresh-token-validity-in-seconds}") long refreshTokenValiditySeconds) {
        this.secretKey = secretKey;
        this.accessTokenValidityMilliSeconds = accessTokenValiditySeconds * 1000;
        this.refreshTokenValidityMilliSeconds = refreshTokenValiditySeconds * 1000;
    }

    @PostConstruct
    public void initKey() {
        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        this.secretkey = Keys.hmacShaKeyFor(keyBytes);
    }
    ...
}

 

각 토큰에 대한 만료시간과 secreyKey 값은 yml 설정 정보를 토대로 생성자 주입하고, 생성자 주입 후 JWT 생성에 사용될 Key는 initKey() 메소드로 secretKey를 decode하여 Key에 주입해주었습니다.

 

	// access, refresh Token 생성
    public TokenDto createToken(String email, String role) {
        long now = (new Date()).getTime();

        Date accessValidity = new Date(now + this.accessTokenValidityMilliSeconds);
        Date refreshValidity = new Date(now + this.refreshTokenValidityMilliSeconds);

        String accessToken = Jwts.builder()
                .addClaims(Map.of(AUTH_EMAIL, email))
                .addClaims(Map.of(AUTH_KEY, role))
                .signWith(secretkey, SignatureAlgorithm.HS256)
                .setExpiration(accessValidity)
                .compact();

        String refreshToken = Jwts.builder()
                .addClaims(Map.of(AUTH_EMAIL, email))
                .addClaims(Map.of(AUTH_KEY, role))
                .signWith(secretkey, SignatureAlgorithm.HS256)
                .setExpiration(refreshValidity)
                .compact();

        return TokenDto.of(accessToken, refreshToken);
    }
    
    // token이 유효한 지 검사
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(secretKey)
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) {
            return false;
        } catch (UnsupportedJwtException e) {
            return false;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    // token이 만료되었는지 검사
    public boolean validateExpire(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(secretKey)
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (ExpiredJwtException e) {
            return false;
        }
    }
 	
    // token으로부터 Authentication 객체를 만들어 리턴하는 메소드
    public Authentication getAuthentication(String token) {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(secretKey)
                .build()
                .parseClaimsJws(token)
                .getBody();

        List<String> authorities = Arrays.asList(claims.get(AUTH_KEY)
                .toString()
                .split(","));

        List<? extends GrantedAuthority> simpleGrantedAuthorities = authorities.stream()
                .map(auth -> new SimpleGrantedAuthority(auth))
                .collect(Collectors.toList());

        KakaoMemberDetails principal = new KakaoMemberDetails(
                (String) claims.get(AUTH_EMAIL),
                simpleGrantedAuthorities, Map.of());

        return new UsernamePasswordAuthenticationToken(principal, token, simpleGrantedAuthorities);
    }
}

 

• TokenProvider에서 토큰 생성 뿐만 아니라 토큰 검증 관련 메소드와, 토큰으로부터 Authentication 객체를 리턴하는 기능들을 추가 구현했습니다.

TokenProvider라기에는 토큰 생성 외의 기능들도 있어 추후 클래스 분리를 하던지, 리네이밍 하던지 수정하도록 하겠습니다 !

 

createToken()

public TokenDto createToken(String email, String role) {
    long now = (new Date()).getTime();

    Date accessValidity = new Date(now + this.accessTokenValidityMilliSeconds);
    Date refreshValidity = new Date(now + this.refreshTokenValidityMilliSeconds);

    String accessToken = Jwts.builder()
            .addClaims(Map.of(AUTH_EMAIL, email))
            .addClaims(Map.of(AUTH_KEY, role))
            .signWith(secretkey, SignatureAlgorithm.HS256)
            .setExpiration(accessValidity)
            .compact();

    String refreshToken = Jwts.builder()
            .addClaims(Map.of(AUTH_EMAIL, email))
            .addClaims(Map.of(AUTH_KEY, role))
            .signWith(secretkey, SignatureAlgorithm.HS256)
            .setExpiration(refreshValidity)
            .compact();

    return TokenDto.of(accessToken, refreshToken);
}

• createToekn 메소드에서 email과 role과 위에서 주입한 시크릿 키와 함께 accessToken과 refreshToken을 만들 수 있습니다. 
• 이 외의 메소드는 어렵지 않으므로 따로 설명하지는 않겠습니다 !

이제 후처리 서비스로 로그인 처리가 끝난 후 이 클래스를 통해 Token을 사용자에게 발급하도록 구현해보겠습니다.

 

---

2. OAuth2SuccessHandler 

@Component
@RequiredArgsConstructor
public class OAuth2SuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    private static final String REDIRECT_URI = "http://localhost:8080/api/sign/login/kakao?accessToken=%s&refreshToken=%s";

    private final TokenProvider tokenProvider;
    private final MemberRepository memberRepository;

    @Transactional
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                        Authentication authentication) throws IOException, ServletException {
        OAuth2User oAuth2User = (OAuth2User) authentication.getPrincipal();
        KakaoUserInfo kakaoUserInfo = new KakaoUserInfo(oAuth2User.getAttributes());

        Member member = memberRepository.findByEmail(kakaoUserInfo.getEmail())
                .orElseThrow(MemberNotFoundException::new);

        TokenDto tokenDto = tokenProvider.createToken(member.getEmail(), member.getRole().name());

        String redirectURI = String.format(REDIRECT_URI, tokenDto.getAccessToken(), tokenDto.getRefreshToken());
        getRedirectStrategy().sendRedirect(request, response, redirectURI);
    }

• SimpleUrlAuthenticationSuccessHandler를 상속하여 onAuthenticaitonSuccess() 메소드를 오버라이딩하면  Authentication 객체를 추가적으로 처리할 수 있는데요.
• 후처리 서비스인 KakaoMemberDetailsService에서 시큐리티 컨텍스트에 Authentication 객체를 저장한 덕분에 이로부터 저는 사용자 정보를 꺼내와 token 정보를 생성하고 이 토큰 정보를 파라미터에 담아 redirect URI로 보내도록 처리했습니다. 이렇게 등록한 핸들러는 SecurityConfig에 추가적으로 등록해주면 되겠습니다 !

 

SecurityConfig에 등록

.oauth2Login(oAuth2Login -> {
    oAuth2Login.userInfoEndpoint(userInfoEndpointConfig ->
            userInfoEndpointConfig.userService(kakaoMemberDetailsService)); // 1
    oAuth2Login.successHandler(oAuth2SuccessHandler); // 2
});

 

** 카카오 로그인에 성공한 경우 1번이 먼저 실행되고, 그 후 2번이 실행됩니다. 

 

위 onAuthenticationSuccess() 메소드에서 리다이렉트된 URI는 아래 컨트롤러에 매핑되어 Json으로 클라이언트에게 넘겨줍니다.

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/sign")
public class SignController {

    @GetMapping("/login/kakao")
    public ResponseEntity loginKakao(@RequestParam(name = "accessToken") String accessToken,
                                     @RequestParam(name = "refreshToken") String refreshToken) {
        return new ResponseEntity(TokenDto.of(accessToken, refreshToken), HttpStatus.OK);
    }
    ...

 

토큰 발급은 모두 끝났습니다. 마지막으로 사용자로부터 요청이 왔을 때, 사용자가 헤더에 첨부한 토큰들이 유효한지 검증하는 필터와 필터에 통과하지 못했을 때 처리할 handler를 등록해주면 되겠습니다.

 

---

3. JWT Filter 

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {

    private static final String ACCESS_HEADER = "AccessToken";
    private static final String REFRESH_HEADER = "RefreshToken";

    private final TokenProvider tokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        // #1
        if (isRequestPassURI(request, response, filterChain)) {
            return;
        }

        String accessToken = getTokenFromHeader(request, ACCESS_HEADER);

        if (tokenProvider.validate(accessToken) && tokenProvider.validateExpire(accessToken)) {
            SecurityContextHolder.getContext().setAuthentication(tokenProvider.getAuthentication(accessToken));
        }

        filterChain.doFilter(request, response);
    }
    ...
}

• 만약 토큰 유효성 검증이 필요하지 않은 요청 URI라면 1번 로직이 실행되어 필터를 통과합니다.
  • 유효성 검증이 필요하지 않은 요청이라 함은 로그인 api, 예외처리 end point api 등등
• 만약 토큰 유효성 검증이 필요한 요청이라면 getTokenFromHeader를 통해 헤더에서 accessToken을 가져오고 tokenProvider에서 검증을 위임하여 통과하면, 토큰으로부터 authentication 객체를 만들어 시큐리티 컨텍스트에 보관하고 필터에 통과합니다.
• 검증에 실패한 경우에 대한 처리는 아래에서 별도로 처리
• 이 필터 또한 SecurityConfig에 등록해주면 되겠습니다.

SecurityConfig에 등록

.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)

• 별도의 자체 인증 로직을 구현한 JwtFilter를 위와 같이 등록하여 기존 시큐리티 로직의 UsernamePasswordAuthenticationFilter를 대체해줍시다.

---

4. JWT Handler 

마지막으로 JWT Filter를 통과하지 못한 경우에 대하여 처리해주어야 합니다. 통과 하지 못한 경우라 함은 인증에 통과되지 못한 경우, 또는 인가(권한)에 통과하지 못한 경우 두 가지가 있겠습니다. 

 

1) 인증 실패

@Component
public class JwtAuthenticationFailEntryPoint implements AuthenticationEntryPoint {

    private static final String EXCEPTION_ENTRY_POINT = "/api/exception/entry-point";

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        response.sendRedirect(EXCEPTION_ENTRY_POINT);
    }
}

• 인증에 대한 실패 처리 핸들러는 AuthenticationEntryPoint 인터페이스의 commence 메소드를 구현하면 되겠습니다.

 

2) 인가 실패 (권한 미달)

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {

    private static final String EXCEPTION_ACCESS_HANDLER = "/api/exception/access-denied";

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
                       AccessDeniedException accessDeniedException) throws IOException {
        response.sendRedirect(EXCEPTION_ACCESS_HANDLER);
    }
}

• 인가에 대한 실패 처리 핸들러는 AccessDeniedHandler 인터페이스의 handler 메소드를 구현하면 되겠습니다.

저는 인증/인가에 실패한 경우, 아래 컨트롤러에서 해당 URI을 받아 예외를 던지도록 처리하였고, 예외는 @ExceptionAdvisor에서 받아서 클라이언트에게 응답하도록 설정해주었습니다.

 

@RestController
@RequestMapping("/api/exception")
public class ExceptionController {

    @GetMapping("/access-denied")
    public void accessDeniedException() {
        throw new AccessDeniedException();
    }

    @GetMapping("/entry-point")
    public void authenticateException() {
        throw new AuthenticationEntryPointException();
    }
}

 

** 이 API에 대한 접근 또한 Jwt필터에서 추가적으로 isRequestPassURI에 등록해줍시다 !

 

 

@RestControllerAdvice
public class ExceptionAdvisor {

    @ExceptionHandler(AccessDeniedException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public ResponseEntity accessDeniedException(AccessDeniedException e) {
        return new ResponseEntity("접근 불가능한 권한입니다.", HttpStatus.UNAUTHORIZED);
    }

    @ExceptionHandler(AuthenticationEntryPointException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public ResponseEntity authenticationEntryPointException(AuthenticationEntryPointException e) {
        return new ResponseEntity("로그인이 필요한 요청입니다.", HttpStatus.UNAUTHORIZED);
    }

 

SecurityConfig에 해당 핸들러 등록

.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)

.exceptionHandling(exceptionHandling -> {
    exceptionHandling.authenticationEntryPoint(jwtAuthenticationFailEntryPoint);
    exceptionHandling.accessDeniedHandler(jwtAccessDeniedHandler);
});

• 마지막으로 핸들러까지 시큐리티 설정정보에 위와 같이 등록해주었습니다.

이렇게 JWT를 도입해보았는데, 다음 포스팅에서는 마지막으로 redis를 도입하여 accessToken가 만료된 경우에 대한 처리를 해보도록 하겠습니다 !