RefreshToken을 적용한 JWT Filter의 로직 알아보기

JWT Filter구현과 리프레쉬 토큰 적용 해보기

현재 진행하는 팀프로젝트에 적용할 JWT에 대해서 알아보고 적용해봅니다.이 포스팅에서는 구현에 대한 세세한 코드를 모두 보여드리진 않습니다. JWT를 사용하고자 하지만 Refresh Token을 아직 사용해보지 못했거나 로직의 흐름을 이해하지 못한 사람들을 위해 로직의

https://velog.io/@pjh612/JWT-%EC%84%A4%EC%A0%95%EA%B3%BC-%EB%A6%AC%ED%94%84%EB%A0%88%EC%89%AC-%ED%86%A0%ED%81%B0-%EC%A0%81%EC%9A%A9-%ED%95%B4%EB%B3%B4%EA%B8%B0

JWT 설정과 리프레쉬 토큰 적용 해보기

JWT란?

고려 사항

DB

RefreshToken의 사용 이유

• JWT가 가진 단점 중 하나는 액세스 토큰 탈취의 우려와, 서버 측에 세션 정보가 저장되는 세션 방식과는 다르게 서버에서 인증을 제어할 수 없어 로그아웃 기능의 구현이 어렵습니다. 또한 비교적 짧은 토큰의 만료기한 때문에 지속적으로 로그인을 다시 해줘야하는 문제점이 있습니다.
• 액세스 토큰 탈취가 되어도 서버 측에서 액세스 토큰을 제어할 수 있는 방법이 필요합니다.
• 로그인을 자동으로 해줄 수 있는 방법이 필요합니다.
• 서버 측에서 클라이언트의 인증 정보를 부분적으로 제어할 수 있어야합니다.

토큰의 저장 위치

JwtAuthenticationFilter(커스텀 필터) 구현

AccessToken만 사용

1. 인증이 필요한 경우 Request의 Header에서 토큰을 가져옵니다.

2. 토큰이 있다면 토큰을 검증하고 디코딩합니다.

• 토큰이 올바르다면 JwtAuthenticationToken을 생성해 SecurityContext에 인증 정보를 저장합니다.

• 토큰이 올바르지 않다면 예외를 발생시킵니다.

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws
		IOException,
		ServletException {

		if (SecurityContextHolder.getContext().getAuthentication() == null) {
			String token = getToken((HttpServletRequest)request);

			if (token != null) {
				try {
					Jwt.Claims claims = verify(token);
					log.debug("Jwt parse result: {}", claims);
					String username = claims.username;
					List<GrantedAuthority> authorities = getAuthorities(claims);

					if (isNotEmpty(username) && authorities.size() > 0) {
						JwtAuthenticationToken authenticationToken = new JwtAuthenticationToken(new JwtAuthentication(token,username)
							, null, authorities);
						authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(
							(HttpServletRequest)request));
						SecurityContextHolder.getContext().setAuthentication(authenticationToken);
					}
				} catch (JWTVerificationException e) {
					log.warn("Jwt processing failed: {}", e.getMessage());
				}
			}
		} else {
			log.debug("SecurityContextHolder not populated with security token, as it already contained: {}",
				SecurityContextHolder.getContext().getAuthentication());
		}
		chain.doFilter(request, response);
	}

RefreshToken 추가 사용

1. GenericFilterBean은 매 서블릿마다 doFilter를 수행합니다. 실제로 GenericFilterBean을 상속받아서 구현하면 한번 Request를 보낼 때 여러번 JwtAuthenticationFilter를 거칩니다. 매 서블릿 마다 같은 필터를 거칠 필요는 없습니다. 인증은 단 한번만 수행하면 됩니다.

2. ShouldNotFilter 함수를 제공해줍니다. 회원 가입, 로그인같은 경우에는 JWT Authentication Filter를 거칠 필요가 없습니다. OncePerRequestFilter는 ShouldNotFilter() 라는 특정 조건에 따라 Filter를 스킵하는 유용한 메서드를 제공 합니다. 필요 시에 JWT Filter만 스킵할 수 있습니다.

JwtAuthenticationFilter.java

package com.kdt.instakyuram.security.jwt;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.kdt.instakyuram.auth.dto.TokenResponse;
import com.kdt.instakyuram.auth.service.TokenService;
import com.kdt.instakyuram.exception.EntityNotFoundException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {
	private final Jwt jwt;
	private final TokenService tokenService;
	private final Logger log = LoggerFactory.getLogger(getClass());

	public JwtAuthenticationFilter(Jwt jwt, TokenService tokenService) {
		this.jwt = jwt;
		this.tokenService = tokenService;
	}

	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
		FilterChain filterChain) throws ServletException, IOException {

		logRequest(request);

		try {
			authenticate(getAccessToken(request), request, response);
		} catch (JwtTokenNotFoundException e) {
			this.log.warn(e.getMessage());
		}
		filterChain.doFilter(request, response);
	}

	private void logRequest(HttpServletRequest request) {
		log.info(String.format(
			"[%s] %s %s",
			request.getMethod(),
			request.getRequestURI().toLowerCase(),
			request.getQueryString() == null ? "" : request.getQueryString())
		);
	}

	private String getAccessToken(HttpServletRequest request) {
		if (request.getCookies() != null) {
			return Arrays.stream(request.getCookies())
				.filter(cookie -> cookie.getName().equals(this.jwt.accessTokenProperties().header()))
				.findFirst()
				.map(Cookie::getValue)
				.orElseThrow(() -> new JwtAccessTokenNotFoundException("AccessToken is not found"));
		} else {
			throw new JwtAccessTokenNotFoundException("AccessToken is not found.");
		}
	}

	private void authenticate(String accessToken, HttpServletRequest request, HttpServletResponse response) {
		try {
			Jwt.Claims claims = verify(accessToken);
			JwtAuthenticationToken authentication = createAuthenticationToken(claims, request, accessToken);
			SecurityContextHolder.getContext().setAuthentication(authentication);
			this.log.info("set Authentication");

		} catch (TokenExpiredException exception) {
			Cookie cookie = new Cookie(jwt.accessTokenProperties().header(), "");
			cookie.setPath("/");
			cookie.setMaxAge(0);
			cookie.setHttpOnly(true);
			response.addCookie(cookie);
			this.log.warn(exception.getMessage());
			refreshAuthentication(accessToken, request, response);
		} catch (JWTVerificationException exception) {
			log.warn(exception.getMessage());
		}
	}

	private JwtAuthenticationToken createAuthenticationToken(Jwt.Claims claims, HttpServletRequest request,
		String accessToken) {
		List<GrantedAuthority> authorities = this.jwt.getAuthorities(claims);
		if (claims.memberId != null && !authorities.isEmpty()) {
			JwtAuthentication authentication = new JwtAuthentication(accessToken, claims.memberId, claims.username);
			JwtAuthenticationToken authenticationToken = new JwtAuthenticationToken(authentication, null, authorities);
			authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

			return authenticationToken;
		} else {
			throw new JWTDecodeException("Decode Error");
		}
	}

	private void refreshAuthentication(String accessToken, HttpServletRequest request, HttpServletResponse response) {
		try {
			String refreshToken = getRefreshToken(request);
			if (isValidRefreshToken(refreshToken, accessToken)) {
				String reIssuedAccessToken = accessTokenReIssue(accessToken);
				Jwt.Claims reIssuedClaims = verify(reIssuedAccessToken);
				JwtAuthenticationToken authentication = createAuthenticationToken(reIssuedClaims, request,
					reIssuedAccessToken);
				SecurityContextHolder.getContext().setAuthentication(authentication);
				Cookie cookie = new Cookie(this.jwt.accessTokenProperties().header(), reIssuedAccessToken);
				cookie.setHttpOnly(true);
				cookie.setPath("/");
				cookie.setMaxAge(this.jwt.accessTokenProperties().expirySeconds());
				response.addCookie(cookie);
			} else {
				log.warn("refreshToken expired");
			}
		} catch (JwtTokenNotFoundException | JWTVerificationException e) {
			this.log.warn(e.getMessage());
		}
	}

	private String getRefreshToken(HttpServletRequest request) {
		if (request.getCookies() != null) {
			return Arrays.stream(request.getCookies())
				.filter(cookie -> cookie.getName().equals(this.jwt.refreshTokenProperties().header()))
				.findFirst()
				.map(Cookie::getValue)
				.orElseThrow(() -> new JwtRefreshTokenNotFoundException("RefreshToken is not found."));
		} else {
			throw new JwtRefreshTokenNotFoundException();
		}
	}

	private boolean isValidRefreshToken(String refreshToken, String accessToken) {
		try {
			TokenResponse foundRefreshToken = this.tokenService.findByToken(refreshToken);
			Long memberId = this.jwt.decode(accessToken).memberId;
			if (memberId.equals(foundRefreshToken.memberId())) {
				this.jwt.verify(foundRefreshToken.token());

				return true;
			}
		} catch (EntityNotFoundException | JWTVerificationException e) {
			log.warn(e.getMessage());

			return false;
		}
		return false;
	}

	private String accessTokenReIssue(String accessToken) {
		return jwt.generateAccessToken(this.jwt.decode(accessToken));
	}

	private Jwt.Claims verify(String token) {
		return jwt.verify(token);
	}
}

1. getAccessToken()

• 액세스 토큰을 쿠키로부터 가져 옵니다. 토큰이 없다면 예외를 발생합니다.

1. authenticate()

• accessToken이 있다면 토큰을 검증과 동시에 디코딩 합니다. (위변조 되진 않았는지, 토큰이 만료되진 않았는지 등)

• 토큰이 만료되면 리프레쉬 토큰을 통해 AccessToken을 재발급 받습니다.

• 그 외 토큰 검증 오류가 발생하면 예외를 발생시키고 종료합니다.

• 검증에 통과 한다면 디코딩된 데이터를 토대로 authenticationToken을 만들고 SecurityContextHolder에 인증 정보를 세팅 합니다. (createAuthenticationToken(), setAuthentication())

• 쿠키로부터 RefreshToken을 찾습니다. 없다면 예외를 발생시키고 종료합니다.

• 토큰이 있다면 검증을 합니다. (isValidRefreshToken()) DB에 저장된 RefreshToken의 userID와 AccessToken내의 userID가 같은지 확인을 합니다.

• 토큰이 있다면 만료된 accessToken을 디코딩해 정보를 가져오고 새 accessToken을 만드는 데 사용합니다. (accessTokenReIssue())

• 재발급된 토큰을 다시 SecurityContextHolder에 인증 정보를 세팅해줍니다.

로그아웃 기능에 대한 생각