JWT 🍳

JWT란?

JWT는 JSON Web Token의 약자로, 토큰 기반 인증을 지원하는 것

→ 토큰을 인증에 사용 (서버에서 클라이언트를 구분하기 위한 유일한 값)

서버에서 토큰을 생성하여 클라이언트에게 전달 → 클라이언트는 토큰을 가지고 있다가 여러 요청과 토큰을 함께 보냄 → 서버에서 유효성 검사 후 토큰이 유효하다면 클라이언트의 요청을 성공적으로 처리

언제 사용하는가?

• 권한 부여 : JWT를 사용하는 가장 일반적인 방식. 사용자가 로그인하면 각 후속 요청에 JWT가 포함되어 사용자가 해당 토큰으로 서비스 및 리소스에 접근
• 정보 교환 : JWT는 정보를 안전하게 전송하는 좋은 방법. 공개/개인 키 쌍을 사용해 JWT에 서명이 가능하다는 것을 이용해 발신자가 누군지 식별 가능

장점

1. 크기 : JSON으로 생성된 토큰은 용량이 작기 때문에 매우 빠르게 전달 가능
2. 안정성 : HMAC 알고리즘 또는 RSA or ECDSA를 사용하는 공개/개인 키 쌍을 사용하여 서명할 수 있기 때문에 무결성이 보장
3. 무상태성(Stateless)
   • 세션 기반은 상태를 갖는다
   • 토큰은 서버가 아닌 클라이언트 측에서 관리한다. 브라우저의 로컬 스토리지 혹은 쿠키에 저장되고, 이 토큰을 HTTP 요청과 함께 서버 측에 보내면 서버는 이 토큰에 대한 위변조 검사 및 만료 여부 등의 유효성 검사를 실시
   • 토큰 기반 인증방식은 서버 측에서 클라이언트의 상태를 직접적으로 관리하지 않으므로 높은 확장성을 가질 수 있게 된다.

구조

header / payload / signature
세가지로 이루어져 있으며, 각각은 ‘.’으로 구분한다. (헤더, 내용, 서명)

JWT를 디버깅 할 수 있는 사이트
https://jwt.io/#debugger-io

헤더 (Header)

토큰의 타입(type)과 해싱 알고리즘(alg)를 지정

내용 (Payload)

토큰에 담을 정보

• 토큰에 담을 하나의 정보, 한 조각의 정보를 클레임(Claim)이라고 한다.

• 등록된 클레임 (registered claim)

  • 서비스에 필요한 정보가 아니라 토큰에 대한 정보들을 담기 위해 이름이 이미 정해져 있는 클레임
  • 필수는 아니지만 권장되는 클레임
  • iss(발급자), sub(제목), aud(대상자), exp(만료시간), nbf(토큰의 활성날짜), iat(발급된 시간), jti(JWT 고유 식별자, 일회용 토큰에 사용)

• 공개 클레임 (public claim)

  • 공개 클레임은 사용자 정의 클레임으로, 공개용 정보 전달을 위해 사용. 충돌을 방지하기 위해 URI 포맷을 이용

• 비공개 클레임 (private claim)

  • 비공개 클레임은 등록된 클레임도 아니고, 공개 클레임도 아닌 당사자간에 정보를 공유하기 위해 만들어진 사용자 지정 클레임
  • 이공세 인증 정보 등의 서버와 클라이언트간 필요한 정보를 넣어두는 형식

{
  "sub": "accessToken", // 등록된 클레임 (제목)
  "name": "tester", // 비공개 클레임
  "email" : "test@test.com" // 비공개 클레임
  "iat": 2020233022 // 등록된 클레임 (발급된 시간)
}

서명 (Signature)

토큰을 인코딩하거나 유효성 검증을 할 때 사용하는 고유한 암호화 코드

서명은 위에서 만든 헤더와 페이로드의 값을 각각 BASE64로 인코딩하고, 인코딩 한 값을 비밀 키를 이용하여 헤더에서 정한 알고리즘으로 해싱을 한 후 다시 BASE64로 인코딩 하여 생성

토큰 기반 인증의 문제점

Stateless 서버는 한 가지 문제점이 존재 → 세션 기반의 인증과 같이 서버 쪽에서 관리가 되고 있지 않기 때문에 올바른 사용자인지, 아니면 누군가 토큰을 탈취해 악의적인 의도로 접근해 온 사용자인지 알지 못한다는 것

때문에 엑세스 토큰의 유효 기간을 아예 짧게 설정하는 것으로 나름 보안을 강화할 수 있지만, 그러면 사용하는 입장에선 불편함을 느낄 수 밖에 없다.

→ 이를 해결할 수 있는 것이 Refresh Token

리프레쉬 토큰은 엑세스 토큰이 만료되었을 때, 엑세스 토큰을 새로 발급하기 위한 토큰

엑세스 토큰과 다른 점은 리프레시 토큰은 엑세스 토큰보다 유효기간이 길고, 데이터 베이스에 저장

RefreshToken 인증 과정

1. 클라이언트 측에서 서버에 인증 요청

2. 서버측에서 엑세스 토큰과 리프레시 토큰 두 개를 클라이언트 측에 전송

3. 클라이언트는 전송받은 토큰을 저장

4. 서버에서는 리프레시 토큰을 데이터베이스에 저장

5. 클라이언트 측에서 인증이 필요한 API 요청을 서버측에 보낼 때마다 엑세스 토큰을 같이 전송

6. 서버 측에서는 전달받은 엑세스 토큰에 대한 유효성 검사 후 유효하다면 클라이언트 요청을 처리. 만약 만료되었다면, 토큰이 만료되었다는 에러를 클라이언트에게 전달

7. 에러를 전달받은 클라이언트는 리프레시 토큰과 함께 새 엑세스 토큰을 서버 측에 요청

8. 서버에서는 리프레시 토큰 유효성 검사를 위해 데이터베이스에서 리프레시 토큰을 조회 후 비교

9. 유효하다면 새 엑세스 토큰을 발급하고 클라이언트에게 전달. 클라이언트는 새 엑세스 토큰을 가지고 원래 요청하려던 API를 다시 요청

JWT 사용시 주의점

인증에서 사용자가 자격증명을 사용하여 성공적으로 로그인하면 JSON 웹 토큰이 반환된다. 토큰은 자격증명을 주 목적으로 사용하므로 보안 문제에 주의가 필요하다.

• 일반적으로 토큰을 필요이상으로 오래 보관하면 안된다.
• 보안에 취약할 수 있기 때문에 민간함 세션 데이터를 브라우저 저장소에 저장해서는 안된다.
• 클라이언트가 보호된 경로 또는 리소스에 접근하려고 할 때 마다, 클라이언트는 일반적으로 Bearer 스키마를 사용하여 Authorization 헤더에서 JWT를 보내야 한다.

JWT 사용해보기

JwtService 구현체

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

    //== jwt.yml에 설정된 값 가져오기 ==//
    @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;

    //== 1 ==//
    private static final String ACCESS_TOKEN_SUBJECT = "AccessToken";
    private static final String REFRESH_TOKEN_SUBJECT = "RefreshToken";
    private static final String USERNAME_CLAIM = "email";
    private static final String BEARER = "Bearer ";

    private final UserRepository usersRepository;
    private final ObjectMapper objectMapper;

    //== 메서드 ==//
    
    // AccessToken 생성 (사용자의 email 기반)
    @Override
    public String createAccessToken(String email) {
        Users user = usersRepository.findByEmail(email)
                .orElseThrow(() -> new IllegalArgumentException("해당 유저가 없습니다."));

        // RelationRepository를 통해 유저의 그룹 이름 조회
        List<String> groupNames = relationRepository.findGroupNamesByUserId(user.getUserId());

        return JWT.create()
                // 빌더를 통해 JWT의 Subject 설정 : AccessToken
                .withSubject(ACCESS_TOKEN_SUBJECT)
                // 만료시간 설정
                .withExpiresAt(new Date(System.currentTimeMillis() + accessTokenValidityInSeconds * 1000))
                // claim으로 email 설정
                .withClaim(USERNAME_CLAIM, email)
                // 해당 유저가 속한 그룹의 이름들을 리스트로 설정
                .withClaim("groups", groupNames)
                // HMA512 알고리즘을 사용하여, secret키로 암호화
                .sign(Algorithm.HMAC512(secret));
    }

		// RefreshToken 생성
    @Override
    public String createRefreshToken() {
        return JWT.create()
					      // 빌더를 통해 JWT의 Subject 설정 : RefreshToken
                .withSubject(REFRESH_TOKEN_SUBJECT)
                // 만료시간 설정
                .withExpiresAt(new Date(System.currentTimeMillis() + refreshTokenValidityInSeconds * 1000))
                // HMA512 알고리즘을 사용하여, secret키로 암호화
                .sign(Algorithm.HMAC512(secret));
    }

		// RefreshToken 유저에게 Update
    @Override
    public void updateRefreshToken(String email, String refreshToken) {
		    // 해당 email을 가지는 유저 찾기
        usersRepository.findByEmail(email)
                .ifPresentOrElse(
					              // 존재하면 refreshToken 업데이트
                        users -> users.updateRefreshToken(refreshToken),
                        () -> new Exception("회원 조회 실패")
                );
    }

		// RefreshToken 삭제
    @Override
    public void destroyRefreshToken(String email) {
    		// 해당 email을 가지는 유저 찾기
        usersRepository.findByEmail(email)
                .ifPresentOrElse(
				        			  // 존재하면 refreshToken 업데이트
                        users -> users.destroyRefreshToken(),
                        () -> new Exception("회원 조회 실패")
                );
    }

		// AccessToken과 RefreshToken을 클라이언트에게 전달
    @Override
    public void sendAccessAndRefreshToken(HttpServletResponse response, String accessToken, String refreshToken) {
        // 응답 메시지의 상태를 200 OK로 설정
        response.setStatus(HttpServletResponse.SC_OK);

				// AccessToken, RefreshToken을 헤더에 담음
        setAccessTokenHeader(response, accessToken);
        setRefreshTokenHeader(response, refreshToken);

				// tokenMap에 두 개의 토큰 내용을 저장
        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put(ACCESS_TOKEN_SUBJECT, accessToken);
        tokenMap.put(REFRESH_TOKEN_SUBJECT, refreshToken);

    }

		// AccessToken을 클라리언트에게 전달
    @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);
    }

		// 클라이언트에게서 전달받은 AccessToken을 HTTP 헤더에서 추출
    @Override
    public Optional<String> extractAccessToken(HttpServletRequest request) {
        return Optional.ofNullable(request.getHeader(accessHeader)).filter(
				        // BEARER 접두사로 시작하는 AccessToken을 확인
                accessToken -> accessToken.startsWith(BEARER)
                // 찾으면 BEARER 부분을 제외한 AccessToken을 반환
        ).map(accessToken -> accessToken.replace(BEARER, ""));
    }

		// 클라이언트에게서 전달받은 RefreshToken을 HTTP 헤더에서 추출
    @Override
    public Optional<String> extractRefreshToken(HttpServletRequest request) {
        return Optional.ofNullable(request.getHeader(refreshHeader)).filter(
        				// BEARER 접두사로 시작하는 RefreshToken을 확인
                refreshToken -> refreshToken.startsWith(BEARER)
                // 찾으면 BEARER 부분을 제외한 RefreshToken을 반환
        ).map(refreshToken -> refreshToken.replace(BEARER, ""));
    }

		// AccessToken에서 email을 claim을 추출하여 맞는지 확인 
    @Override
    public Optional<String> extractEmail(String accessToken) {
        try {
            return Optional.ofNullable(
					          // JWT 라이브러리를 이용해 accessToken 속 email을 추출 (USERNAME_CLAIM)
                    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;
        }
    }

}

AccessToken을 이용한 인증 필터

필터 요구사항

• /login 으로 오는 요청에 대해서는 필터 작동 X → JsonUsernamePasswordAuthenticationFilter에 위임
• 그 외에 들어오는 모든 요청에 대해서 작동
• RefreshToken을 포함하여 요청이 전송되는 경우는 4가지 상황이 존재
  1. 둘다 유효 → AccessToken 재발급, 인증 진행 X
  2. RefreshToken만 유효 → AccessToken 재발급
  3. AccessToken만 유효 → 인증은 성공되나, RefreshToken 재발급 X
  4. RefreshToken과 AccessToken 모두 없거나 유효하지 않는 경우 → 인증 실패

JwtAuthenticationProcessingFilter

OncePerRequestFilter 상속 구현 클래스 → 모든 서블릿 컨테이너에서 요청 디스패치당 단일 실행을 보장하는 것을 목표로 하는 필터 기본 클래스

@RequiredArgsConstructor
public class JwtAuthenticationProcessingFilter extends OncePerRequestFilter {

    private final JwtService jwtService;

    private final UserRepository userRepository;

    private GrantedAuthoritiesMapper authoritiesMapper = new NullAuthoritiesMapper();

    private final String NO_CHECK_URL = "/login";

     /**
     * 1. 리프레시 토큰이 오는 경우 -> 유효하면 AccessToken 재발급후, 필터 진행 X, 바로 튕기기
     *
     * 2. 리프레시 토큰은 없고 AccessToken만 있는 경우 -> 유저정보 저장후 필터 계속 진행
     */

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // /login으로 접근시 필터 적용 X
        if(request.getRequestURI().equals(NO_CHECK_URL)) {
            filterChain.doFilter(request, response);
            return; //안해주면 아래로 내려가서 계속 필터를 진행하게됨
        }
				
				// refreshToken을 요청 HTTP에서 찾아 검증
        String refreshToken = jwtService
                .extractRefreshToken(request)
                .filter(jwtService::isTokenValid)
                .orElse(null); // RefreshToken이 없거나 유효하지 않으면 null을 반환

				// refreshToken이 존재할 경우 
        if(refreshToken != null){
			      // refreshToken이 존재하는지 확인하고, 사용자에게 AccessToken 재발급
            checkRefreshTokenAndReIssueAccessToken(response, refreshToken);
            return; // 인증을 처리하지 않게 하기 위해 return
        }

				// refreshToken이 없다면 AccessToken을 검사하는 로직 수행
        checkAccessTokenAndAuthentication(request, response, filterChain); 
    }

    private void checkAccessTokenAndAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        jwtService.extractAccessToken(request).filter(jwtService::isTokenValid).ifPresent(
                // AccessToken이 존재하고 유효하다면
                // AccessToken에서 email을 추출하고, email로 유저 정보를 찾아서 인증처리
                accessToken -> jwtService.extractEmail(accessToken).ifPresent(
			
                        email -> userRepository.findByEmail(email).ifPresent(
																// 인증 처리
                                users -> saveAuthentication(users)
                        )
                )
        );

        filterChain.doFilter(request,response);
    }

    private void saveAuthentication(Users users) {
        UserDetailsImpl userDetails = new UserDetailsImpl(users);

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

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

    private void checkRefreshTokenAndReIssueAccessToken(HttpServletResponse response, String refreshToken) {
        // 해당하는 refreshToken이 DB에 존재하면, user에게 AccessToken 발급
        userRepository.findByRefreshToken(refreshToken).ifPresent(
                users -> jwtService.sendAccessToken(response, jwtService.createAccessToken(users.getEmail()))
        );

    }
}

참고

JWT란 무엇인가?