feat(Jwt): Auth, Filter, Exception (#50)

* feat(JwtParser): JWT 파싱 예외 처리 추가

* feat(JwtRefresher): 프론트엔드와 협의한 JWT 갱신 로직 완성

* feat(JwtValidator): 명확한 검증을 위해 boolean 반환에서 예외 반환으로 수정

* feat(JwtGenerator): 동일 시점 생성 토큰을 JTI로 구분

* feat(JwtService): JWT 서비스 구조 개선 및 기능 추가

- verifyToken 메서드 제거 후 processAccessToken 메서드로 통합.
  - 만료된 AccessToken을 처리하고 갱신된 토큰을 Set-Cookie 헤더에 추가하도록 구현.
  - HttpServletResponse를 활용해 갱신된 AccessToken 설정 로직 추가.

- 만료된 AccessToken에 대한 예외 처리 로직(handleJwtExpiredException) 추가.
  - JwtException을 확인하고 만료된 토큰만 갱신 처리.
  - SetCookieUseCase 의존성 주입을 통해 클라이언트에 새로운 AccessToken 전달.

- JwtRefresher와 SetCookieUseCase를 활용하여 클라이언트 응답에 새로운 AccessToken을 설정하는 책임 분리.
- JwtValidator와 JwtParser를 활용한 검증 및 클레임 추출 구조 간소화.

* feat(JwtValidator): 반환 타입 변경, 내부 예외 처리

* feat(JwtException): Jwt 예외를 위한 메시지와 클래스 추가

* feat(RefreshTokenManager): 예외 타입, 메시지 수정

* feat(JwtAuthenticationToken): 사용자 인증 정보를 커스텀 인증 토큰으로 관리

- 사용자 정보를 담는 principal(userId)과 credentials(accessToken) 필드 추가
- Spring Security의 AbstractAuthenticationToken을 상속받아 SecurityContext와의 호환성 유지
- setAuthenticated(true)를 통해 인증 상태 설정 (생선 전에 검증함)
- 이후 SecurityContextHolder에서 principal 및 권한 정보를 추출하여 사용 가능

* feat(JwtAuthFilter): JWT 기반 인증 필터 구현

- HTTP 요청의 Authorization 헤더에서 JWT 추출
- 추출한 JWT를 검증하고 만료 시 리프레시 처리 (JwtUseCase 활용)
- JWT Claims에서 사용자 ID와 권한을 추출하여 JwtAuthenticationToken 생성
- SecurityContextHolder에 Authentication 객체 등록하여 인증 상태 관리
- shouldNotFilter 메서드로 특정 요청 URI에 대해 필터링 제외 가능 (현재는 개발 중 모든 요청 허용)

* feat(JwtExceptionFilter): JWT 예외 처리 필터 구현

- JWT 처리 중 발생하는 JwtException을 전용 필터에서 처리 (스프링 컨텍스트가 아니므로)
- HTTP 상태 코드 401(Unauthorized)와 함께 ProblemDetail 형식의 JSON 응답 생성
- ProblemDetail 응답에 오류 제목, 유형, 상세 메시지, 타임스탬프 포함

* feat(SecurityConfig): JwtAuthFilter, JwtExceptionFilter 추가

- JwtAuthFilter: 요청 헤더에서 JWT를 검증하고, 인증 정보를 SecurityContext에 설정
- JwtExceptionFilter: JWT 처리 중 발생한 예외를 캡처하고 ProblemDetail 형식으로 응답 반환

* test(JwtServiceTest): 다양한 JWT 테스트 추가

- JWT 토큰 생성 및 검증 로직 테스트:
  - 토큰이 올바르게 생성되고, 예상한 클레임(`id`, `role`, `expiration`)을 포함하는지 확인.
  - 동일 사용자에 대해 여러 토큰 생성 시 서로 다른 값이어야 함을 검증.

- JWT 만료 및 갱신 로직 테스트:
  - 만료된 AccessToken이 RefreshToken이 유효한 경우 갱신되는지 확인.
  - RefreshToken이 유효하지 않거나 존재하지 않을 때 예외 발생을 검증.

- RefreshToken 관련 테스트:
  - 기존 RefreshToken이 올바르게 갱신되는지 확인.
  - RefreshToken이 없거나 잘못된 경우 예외 발생을 검증.

- JWT 예외 처리 테스트:
  - 잘못된 토큰 및 만료된 토큰이 적절한 `JwtException`을 던지는지 확인.

- RefreshToken 저장 및 유효성 확인 테스트:
  - RefreshToken 저장 로직 검증.
  - 갱신된 AccessToken이 쿠키에 올바르게 설정되는지 확인.

* feat(JwtAuthenticationToken): 직렬화 지원 추가

- principal 필드를 직렬화 가능하도록 수정
- credentials 필드는 인증 이후에 사용하지 않으니 직렬화 제외
- 세션 저장 및 분산 서버 환경에서의 호환성 확보

* refactor: unused import 삭제

* style(개행): git 잠재적인 이슈 예방

* style: when, then 주석 행 맞추기

* feat(ProblemDetail): type 삭제

* refactor(JwtAuthFilter): private 메서드 위치 변경

Author: m-a-king

src/main/java/com/somemore/auth/jwt/exception/JwtErrorType.java

@@ -0,0 +1,15 @@
+package com.somemore.auth.jwt.exception;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum JwtErrorType {
+    MISSING_TOKEN("JWT 토큰이 없습니다."),
+    INVALID_TOKEN("JWT 서명이 유효하지 않습니다."),
+    EXPIRED_TOKEN("JWT 토큰이 만료되었습니다."),
+    UNKNOWN_ERROR("알 수 없는 JWT 처리 오류가 발생했습니다.");
+
+    private final String message;
+}

src/main/java/com/somemore/auth/jwt/exception/JwtException.java

@@ -0,0 +1,14 @@
+package com.somemore.auth.jwt.exception;
+
+import lombok.Getter;
+
+@Getter
+public class JwtException extends RuntimeException {
+    private final JwtErrorType errorType;
+
+    public JwtException(JwtErrorType errorType) {
+        super(errorType.getMessage());
+        this.errorType = errorType;
+    }
+
+}

src/main/java/com/somemore/auth/jwt/filter/JwtAuthFilter.java

@@ -0,0 +1,67 @@
+package com.somemore.auth.jwt.filter;
+
+import com.somemore.auth.UserRole;
+import com.somemore.auth.jwt.domain.EncodedToken;
+import com.somemore.auth.jwt.exception.JwtErrorType;
+import com.somemore.auth.jwt.exception.JwtException;
+import com.somemore.auth.jwt.usecase.JwtUseCase;
+import io.jsonwebtoken.Claims;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.util.List;
+
+@RequiredArgsConstructor
+@Slf4j
+@Component
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+    private final JwtUseCase jwtUseCase;
+
+    @Override
+    protected boolean shouldNotFilter(HttpServletRequest request) {
+        return true; // 개발 중 모든 요청 허용
+//        return httpServletRequest.getRequestURI().contains("token");
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
+        EncodedToken accessToken = getAccessToken(request);
+        jwtUseCase.processAccessToken(accessToken, response);
+
+        Claims claims = jwtUseCase.getClaims(accessToken);
+        Authentication auth = createAuthenticationToken(claims, accessToken);
+
+        SecurityContextHolder.getContext().setAuthentication(auth);
+        filterChain.doFilter(request, response);
+    }
+
+    private EncodedToken getAccessToken(HttpServletRequest request) {
+        String accessToken = request.getHeader("Authorization");
+        if (accessToken == null || accessToken.isEmpty()) {
+            throw new JwtException(JwtErrorType.MISSING_TOKEN);
+        }
+        return new EncodedToken(accessToken);
+    }
+
+    private JwtAuthenticationToken createAuthenticationToken(Claims claims, EncodedToken accessToken) {
+        String userId = claims.get("id", String.class);
+        UserRole role = claims.get("role", UserRole.class);
+
+        return new JwtAuthenticationToken(
+                userId,
+                accessToken,
+                List.of(new SimpleGrantedAuthority(role.name()))
+        );
+    }
+}

src/main/java/com/somemore/auth/jwt/filter/JwtAuthenticationToken.java

@@ -0,0 +1,31 @@
+package com.somemore.auth.jwt.filter;
+
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.core.GrantedAuthority;
+
+import java.io.Serializable;
+import java.util.Collection;
+
+public class JwtAuthenticationToken extends AbstractAuthenticationToken {
+    private final Serializable principal;
+    private final transient Object credentials;
+
+    public JwtAuthenticationToken(Serializable principal,
+                                  Object credentials,
+                                  Collection<? extends GrantedAuthority> authorities) {
+        super(authorities);
+        this.principal = principal;
+        this.credentials = credentials;
+        setAuthenticated(true);
+    }
+
+    @Override
+    public Object getCredentials() {
+        return credentials;
+    }
+
+    @Override
+    public Object getPrincipal() {
+        return principal;
+    }
+}

src/main/java/com/somemore/auth/jwt/filter/JwtExceptionFilter.java

@@ -0,0 +1,50 @@
+package com.somemore.auth.jwt.filter;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.somemore.auth.jwt.exception.JwtException;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ProblemDetail;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@RequiredArgsConstructor
+@Slf4j
+@Component
+public class JwtExceptionFilter extends OncePerRequestFilter {
+
+    private final ObjectMapper objectMapper;
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
+        try {
+            filterChain.doFilter(request, response);
+        } catch (JwtException e) {
+            ProblemDetail problemDetail = buildUnauthorizedProblemDetail(e);
+            configureUnauthorizedResponse(response);
+
+            objectMapper.writeValue(response.getWriter(), problemDetail);
+        }
+    }
+
+    private void configureUnauthorizedResponse(HttpServletResponse response) {
+        response.setStatus(HttpStatus.UNAUTHORIZED.value());
+        response.setContentType(MediaType.APPLICATION_PROBLEM_JSON_VALUE);
+        response.setCharacterEncoding("UTF-8");
+    }
+
+    private ProblemDetail buildUnauthorizedProblemDetail(JwtException e) {
+        ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(HttpStatus.UNAUTHORIZED, e.getMessage());
+        problemDetail.setTitle("Authentication Error");
+        problemDetail.setProperty("timestamp", System.currentTimeMillis());
+        return problemDetail;
+    }
+}

src/main/java/com/somemore/auth/jwt/generator/HmacJwtGenerator.java

@@ -11,6 +11,7 @@
 import javax.crypto.SecretKey;
 import java.time.Instant;
 import java.util.Date;
+import java.util.UUID;
 
 @Component
 @RequiredArgsConstructor
@@ -23,9 +24,11 @@ public EncodedToken generateToken(String userId, String role, TokenType tokenTyp
         Claims claims = buildClaims(userId, role);
         Instant now = Instant.now();
         Instant expiration = now.plusMillis(tokenType.getPeriod());
+        String uniqueId = UUID.randomUUID().toString(); // JTI
 
         return new EncodedToken(Jwts.builder()
                 .claims(claims)
+                .id(uniqueId)
                 .issuedAt(Date.from(now))
                 .expiration(Date.from(expiration))
                 .signWith(secretKey, ALGORITHM)

src/main/java/com/somemore/auth/jwt/parser/DefaultJwtParser.java

@@ -1,8 +1,12 @@
 package com.somemore.auth.jwt.parser;
 
 import com.somemore.auth.jwt.domain.EncodedToken;
+import com.somemore.auth.jwt.exception.JwtErrorType;
+import com.somemore.auth.jwt.exception.JwtException;
 import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.ExpiredJwtException;
 import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.SignatureException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
@@ -14,11 +18,21 @@ public class DefaultJwtParser implements JwtParser {
 
     private final SecretKey secretKey;
 
+    @Override
     public Claims parseToken(EncodedToken token) {
-        return Jwts.parser()
-                .verifyWith(secretKey)
-                .build()
-                .parseSignedClaims(token.value())
-                .getPayload();
+        try {
+            return Jwts.parser()
+                    .verifyWith(secretKey)
+                    .build()
+                    .parseSignedClaims(token.value())
+                    .getPayload();
+
+        } catch (SignatureException e) {
+            throw new JwtException(JwtErrorType.INVALID_TOKEN);
+        } catch (ExpiredJwtException e) {
+            throw new JwtException(JwtErrorType.EXPIRED_TOKEN);
+        } catch (Exception e) {
+            throw new JwtException(JwtErrorType.UNKNOWN_ERROR);
+        }
     }
 }

src/main/java/com/somemore/auth/jwt/refresh/manager/RedisRefreshTokenManager.java

@@ -1,9 +1,10 @@
 package com.somemore.auth.jwt.refresh.manager;
 
 import com.somemore.auth.jwt.domain.EncodedToken;
+import com.somemore.auth.jwt.exception.JwtErrorType;
+import com.somemore.auth.jwt.exception.JwtException;
 import com.somemore.auth.jwt.refresh.domain.RefreshToken;
 import com.somemore.auth.jwt.refresh.repository.RefreshTokenRepository;
-import jakarta.persistence.EntityNotFoundException;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -16,19 +17,18 @@ public class RedisRefreshTokenManager implements RefreshTokenManager {
     @Override
     public RefreshToken findRefreshToken(EncodedToken accessToken) {
         return refreshTokenRepository.findByAccessToken(accessToken.value())
-                .orElseThrow(EntityNotFoundException::new);
+                .orElseThrow(() -> new JwtException(JwtErrorType.EXPIRED_TOKEN));
     }
 
     @Override
     public void save(RefreshToken refreshToken) {
         refreshTokenRepository.save(refreshToken);
     }
 
-    // TODO 로그아웃에 사용
     @Override
     public void removeRefreshToken(EncodedToken accessToken) {
         RefreshToken refreshToken = refreshTokenRepository.findByAccessToken(accessToken.value())
-                .orElseThrow(EntityNotFoundException::new);
+                .orElseThrow(() -> new JwtException(JwtErrorType.EXPIRED_TOKEN));
 
         refreshTokenRepository.delete(refreshToken);
     }

src/main/java/com/somemore/auth/jwt/refresh/refresher/DefaultJwtRefresher.java

@@ -25,23 +25,16 @@ public class DefaultJwtRefresher implements JwtRefresher {
     @Override
     public EncodedToken refreshAccessToken(EncodedToken accessToken) {
         RefreshToken refreshToken = refreshTokenManager.findRefreshToken(accessToken);
-        validateToken(refreshToken);
+        EncodedToken refreshTokenValue = new EncodedToken(refreshToken.getRefreshToken());
+        jwtValidator.validateToken(refreshTokenValue);
 
-        Claims claims = jwtParser.parseToken(accessToken);
+        Claims claims = jwtParser.parseToken(refreshTokenValue);
         refreshToken.updateAccessToken(generateAccessToken(claims));
         refreshTokenManager.save(refreshToken);
 
         return new EncodedToken(refreshToken.getAccessToken());
     }
 
-    private void validateToken(RefreshToken refreshToken) {
-        if (jwtValidator.validateToken(new EncodedToken(refreshToken.getAccessToken()))) {
-            // TODO Security Context (JwtFilter) 구현 시 예외 처리 구체화
-            log.error("리프레시 토큰이 만료되었습니다. 로그인을 다시 해야합니다");
-            throw new RuntimeException();
-        }
-    }
-
     private EncodedToken generateAccessToken(Claims claims) {
         return jwtGenerator.generateToken(
                 claims.get("id", String.class),

src/main/java/com/somemore/auth/jwt/service/JwtService.java

@@ -1,12 +1,17 @@
 package com.somemore.auth.jwt.service;
 
+import com.somemore.auth.cookie.SetCookieUseCase;
 import com.somemore.auth.jwt.domain.EncodedToken;
 import com.somemore.auth.jwt.domain.TokenType;
+import com.somemore.auth.jwt.exception.JwtErrorType;
+import com.somemore.auth.jwt.exception.JwtException;
 import com.somemore.auth.jwt.generator.JwtGenerator;
 import com.somemore.auth.jwt.parser.JwtParser;
 import com.somemore.auth.jwt.refresh.refresher.JwtRefresher;
 import com.somemore.auth.jwt.usecase.JwtUseCase;
 import com.somemore.auth.jwt.validator.JwtValidator;
+import io.jsonwebtoken.Claims;
+import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -19,23 +24,33 @@ public class JwtService implements JwtUseCase {
     private final JwtParser jwtParser;
     private final JwtValidator jwtValidator;
     private final JwtRefresher jwtRefresher;
+    private final SetCookieUseCase setCookieUseCase;
 
     @Override
     public EncodedToken generateToken(String userId, String role, TokenType tokenType) {
         return jwtGenerator.generateToken(userId, role, tokenType);
     }
 
     @Override
-    public void verifyToken(EncodedToken token) {
-        if (jwtValidator.validateToken(token)) {
-            return;
+    public void processAccessToken(EncodedToken accessToken, HttpServletResponse response) {
+        try {
+            jwtValidator.validateToken(accessToken);
+        } catch (JwtException e) {
+            handleJwtExpiredException(e, accessToken, response);
         }
-        EncodedToken accessToken = jwtRefresher.refreshAccessToken(token);
-        // TODO Security Context (JwtFilter) 구현 시 setCookie(accessToken) 구체화
     }
 
     @Override
-    public String getClaimByKey(EncodedToken token, String key) {
-        return jwtParser.parseToken(token).get(key, String.class);
+    public Claims getClaims(EncodedToken token) {
+        return jwtParser.parseToken(token);
+    }
+
+    private void handleJwtExpiredException(JwtException e, EncodedToken accessToken, HttpServletResponse response) {
+        if (e.getErrorType() == JwtErrorType.EXPIRED_TOKEN) {
+            EncodedToken refreshedToken = jwtRefresher.refreshAccessToken(accessToken);
+            setCookieUseCase.setToken(response, refreshedToken.value(), TokenType.ACCESS);
+            return;
+        }
+        throw e;
     }
 }