Feat/#21

build.gradle

@@ -34,6 +34,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 	implementation 'org.springframework.boot:spring-boot-starter-security'
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
+	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 	compileOnly 'org.projectlombok:lombok'
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'
 	runtimeOnly 'com.h2database:h2'

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/AuthController.java

@@ -5,6 +5,8 @@
 import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
 import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
 import kr.ac.ks.cs_web_back.domain.auth.service.AuthService;
+import kr.ac.ks.cs_web_back.domain.member.model.Member;
+import kr.ac.ks.cs_web_back.global.annotation.IdentifiedUser;
 import kr.ac.ks.cs_web_back.global.response.CsResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
@@ -23,4 +25,13 @@ public CsResponse<AuthLoginResponse> login(
         AuthLoginResponse token = authService.loginMember(request);
         return CsResponse.of(AuthSuccessCode.LOGIN_SUCCESS, token);
     }
+
+    @PostMapping("/logout")
+    public CsResponse<Void> logout (
+            @Valid @RequestHeader("Authorization") String authorization,
+            @IdentifiedUser Member member
+    ) {
+        authService.logout(authorization, member.getEmail());
+        return CsResponse.of(AuthSuccessCode.LOGOUT_SUCCESS);
+    }
 }

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/SpringDocAuthController.java

@@ -1,15 +1,19 @@
 package kr.ac.ks.cs_web_back.domain.auth.controller;
 
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.parameters.RequestBody;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
 import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
+import kr.ac.ks.cs_web_back.domain.member.model.Member;
+import kr.ac.ks.cs_web_back.global.annotation.IdentifiedUser;
 import kr.ac.ks.cs_web_back.global.response.CsResponse;
 import kr.ac.ks.cs_web_back.global.swagger.error.ApiErrorResponse;
 import kr.ac.ks.cs_web_back.global.swagger.error.ErrorCase;
 import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.RequestHeader;
 
 @Tag(name = "인증 API", description = "인증 관련 API")
 public interface SpringDocAuthController {
@@ -30,4 +34,17 @@ CsResponse<AuthLoginResponse> login(
             @RequestBody AuthLoginRequest request
     );
 
+    @Operation(summary = "로그아웃", description = "사용자의 JWT토큰을 받아 형식을 검사하고 성공시 토큰을 만료시킵니다.")
+    @ApiResponse(responseCode = "200", description = "로그아웃에 성공했습니다.")
+    @ApiErrorResponse(status = HttpStatus.UNAUTHORIZED, instance = "/auth/logout", errorCases = {
+            @ErrorCase(description = "유효하지 않은 토큰", code = 8001, exampleMessage = "유효하지 않은 토큰입니다."),
+            @ErrorCase(description = "인증 실패", code = 8002, exampleMessage = "인증에 실패했습니다.")
+    })
+    @ApiErrorResponse(status = HttpStatus.INTERNAL_SERVER_ERROR, instance = "/auth/logout", errorCases = {
+            @ErrorCase(description = "서버 오류", code = 5000, exampleMessage = "서버에서 예기치 못한 오류가 발생했습니다.")
+    })
+    CsResponse<Void> logout(
+            @RequestHeader("Authorization") String authorizationHeader,
+            @Parameter(hidden=true)@IdentifiedUser Member member
+    );
 }

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/code/AuthExceptionCode.java

@@ -10,9 +10,10 @@ public enum AuthExceptionCode implements ExceptionCode {
 
     BAD_REQUEST_NO_EMAIL(9010, "이메일이 입력되지 않았습니다."),
     BAD_REQUEST_NO_PASSWORD(9010, "비밀번호가 입력되지 않았습니다."),
+
+    UNAUTHORIZED_PASSWORD(8011, "이메일 또는 비밀번호가 일치하지 않습니다."),
     UNAUTHORIZED_INVALID_TOKEN(8001, "유효하지 않은 토큰입니다."),
     UNAUTHORIZED_FAILED_VALIDATION(8002, "인증에 실패했습니다."),
-    UNAUTHORIZED_PASSWORD(8011, "비밀번호가 일치하지 않습니다."),
     ;
 
     private final int code;

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/code/AuthSuccessCode.java

@@ -9,6 +9,7 @@
 public enum AuthSuccessCode implements SuccessCode {
 
     LOGIN_SUCCESS(2001, "로그인에 성공했습니다."),
+    LOGOUT_SUCCESS(2002, "로그아웃에 성공했습니다."),
     ;
 
     private final int code;

src/main/java/kr/ac/ks/cs_web_back/domain/auth/service/AuthService.java

@@ -5,35 +5,69 @@
 import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
 import kr.ac.ks.cs_web_back.domain.member.model.Member;
 import kr.ac.ks.cs_web_back.domain.member.repository.MemberRepository;
+import kr.ac.ks.cs_web_back.global.exeption.domain.InvalidTokenException;
 import kr.ac.ks.cs_web_back.global.exeption.domain.NotFoundException;
 import kr.ac.ks.cs_web_back.global.exeption.domain.UnauthorizedException;
+import kr.ac.ks.cs_web_back.global.jwt.JwtTokenResolver;
 import kr.ac.ks.cs_web_back.global.jwt.JwtUtil;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+
 @Service
 @RequiredArgsConstructor
 @Transactional
 public class AuthService {
 
     private final MemberRepository memberRepository;
     private final PasswordEncoder passwordEncoder;
+    private final RedisTemplate<String, String> redisTemplate;
     private final JwtUtil jwtUtil;
+    private final JwtTokenResolver jwtTokenResolver;
+    private final JwtBlackListService jwtBlackListService;
+
 
     public AuthLoginResponse loginMember(AuthLoginRequest request) {
         Member member = memberRepository.findByEmail(request.email())
                 .orElseThrow(() -> new NotFoundException(AuthExceptionCode.UNAUTHORIZED_FAILED_VALIDATION));
 
         if(!passwordEncoder.matches(request.password(), member.getPassword()))
             throw new UnauthorizedException(AuthExceptionCode.UNAUTHORIZED_PASSWORD);
-        // 24 hours
+
         String accessToken = jwtUtil.generateAccessToken(member.getEmail());
         String refreshToken = jwtUtil.generateRefreshToken(member.getEmail());
+
+        Date refreshTokenExpiration = jwtUtil.getExpirationDateFromRefreshToken(refreshToken);
+        long remainingTime = refreshTokenExpiration.getTime() - System.currentTimeMillis();
+
+        redisTemplate.opsForValue().set(
+                "RT:"+ member.getEmail(),
+                refreshToken,
+                remainingTime,
+                TimeUnit.MILLISECONDS
+        );
+
         return AuthLoginResponse.builder()
                 .authorization(accessToken)
                 .authorizationRefresh(refreshToken)
                 .build();
     }
+    public void logout(String authorization, String email) {
+        String resolvedAccessToken = jwtTokenResolver.resolveToken(authorization);
+
+        if (jwtBlackListService.isBlackListed(resolvedAccessToken))
+            throw new InvalidTokenException(AuthExceptionCode.UNAUTHORIZED_FAILED_VALIDATION);
+
+        if (redisTemplate.opsForValue().get("RT:"+email) != null)
+            redisTemplate.delete("RT:"+email);
+
+        Date expirationTime = jwtUtil.getExpirationDateFromAccessToken(resolvedAccessToken);
+        long remainingTime = expirationTime.getTime() - System.currentTimeMillis();
+        jwtBlackListService.blacklist(resolvedAccessToken, remainingTime);
+    }
 }

src/main/java/kr/ac/ks/cs_web_back/domain/auth/service/JwtBlackListService.java

@@ -0,0 +1,27 @@
+package kr.ac.ks.cs_web_back.domain.auth.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.TimeUnit;
+
+@Service
+@RequiredArgsConstructor
+public class JwtBlackListService {
+
+    private final RedisTemplate<String, String> redisTemplate;
+
+    public void blacklist(String accessToken, long remainingTime) {
+        redisTemplate.opsForValue().set(
+                accessToken,
+                "logout",
+                remainingTime,
+                TimeUnit.MILLISECONDS
+        );
+    }
+
+    public boolean isBlackListed(String accessToken) {
+        return redisTemplate.opsForValue().get(accessToken) != null;
+    }
+}

src/main/java/kr/ac/ks/cs_web_back/global/config/SecurityConfig.java

@@ -28,7 +28,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                 .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                 .authorizeHttpRequests(authz -> authz
                         .requestMatchers(PathRequest.toH2Console()).permitAll() // H2 콘솔 경로 허용
-                        .requestMatchers("/member/register", "/auth/login", "/swagger-ui/**", "/v3/api-docs/**").permitAll()
+                        .requestMatchers("/member/register", "/auth/login", "/auth/logout", "/swagger-ui/**", "/v3/api-docs/**").permitAll()
                         .anyRequest().authenticated()
                 )
                 .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)

src/main/java/kr/ac/ks/cs_web_back/global/exeption/GlobalExceptionHandler.java

@@ -8,6 +8,7 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.FieldError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingRequestHeaderException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
@@ -88,4 +89,13 @@ public ResponseEntity<ExceptionResponse> handleException(final ConflictException
                 .body(new ExceptionResponse(exception.getCode(), exception.getMessage()));
     }
 
+    @ExceptionHandler(MissingRequestHeaderException.class)
+    public ResponseEntity<ExceptionResponse> handleException(final MissingRequestHeaderException e) {
+        System.out.printf("%s : %s\n", e.getClass(), e.getMessage());
+
+        final int errorCode = 400;
+        final String errorMessage = "필수 헤더가 누락되었습니다: " + e.getHeaderName();
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                .body(new ExceptionResponse(errorCode, errorMessage));
+    }
 }

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtAuthenticationFilter.java

@@ -39,7 +39,7 @@ protected void doFilterInternal(
             if (token != null) {
                 jwtUtil.validateToken(token);
 
-                String email = jwtUtil.getEmailFromToken(token);
+                String email = jwtUtil.getEmailFromAccessToken(token);
                 UserDetails userDetails = userDetailsService.loadUserByUsername(email);
                 UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                 SecurityContextHolder.getContext().setAuthentication(authentication);

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtConfig.java

@@ -0,0 +1,26 @@
+package kr.ac.ks.cs_web_back.global.jwt;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+
+@Configuration
+@EnableConfigurationProperties(JwtProperties.class)
+@PropertySource("classpath:env.properties")
+@RequiredArgsConstructor
+public class JwtConfig {
+
+    private final JwtProperties jwtProperties;
+
+    @Bean(name = "accessTokenProvider")
+    public TokenProvider accessTokenProvider() {
+        return new TokenProvider(jwtProperties.accessSecret(), jwtProperties.accessTokenExpireTime());
+    }
+
+    @Bean(name = "refreshTokenProvider")
+    public TokenProvider refreshTokenProvider() {
+        return new TokenProvider(jwtProperties.refreshSecret(), jwtProperties.refreshTokenExpireTime());
+    }
+}

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtProperties.java

@@ -0,0 +1,12 @@
+package kr.ac.ks.cs_web_back.global.jwt;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties(prefix = "jwt")
+public record JwtProperties(
+        String accessSecret,
+        String refreshSecret,
+        Long accessTokenExpireTime,
+        Long refreshTokenExpireTime
+) {
+}

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtTokenResolver.java

@@ -17,4 +17,10 @@ public String resolveToken(HttpServletRequest request) {
         return null;
     }
 
+    public String resolveToken(String authorizationHeader) {
+        if(StringUtils.hasText(authorizationHeader) && authorizationHeader.startsWith(HEADER_PREFIX))
+            return authorizationHeader.substring(HEADER_PREFIX.length());
+
+        return null;
+    }
 }

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtUtil.java

@@ -14,54 +14,76 @@
 
 @Component
 public class JwtUtil {
-    @Value("${jwt.secret}")
-    private String secret;
+    @Value("${jwt.accessSecret}")
+    private String aSecret;
+
+    @Value("${jwt.refreshSecret}")
+    private String rSecret;
 
     @Value("${jwt.accessTokenExpireTime}")
     private Long accessTokenExpireTime;
 
     @Value("${jwt.refreshTokenExpireTime}")
     private Long refreshTokenExpireTime;
 
-    private Key hmacKey;
+    private Key hmacAccessKey;
+    private Key hmacRefreshKey;
 
     @PostConstruct
     public void init() {
-        byte[] decodedKey = Base64.getDecoder().decode(secret);
-        this.hmacKey = new SecretKeySpec(decodedKey, SignatureAlgorithm.HS256.getJcaName());
-    }
-    public String generateAccessToken(String email) {
-        return generateToken(email, accessTokenExpireTime);
-    }
+        byte[] accessDecodedKey = Base64.getDecoder().decode(aSecret);
+        this.hmacAccessKey = new SecretKeySpec(accessDecodedKey, SignatureAlgorithm.HS256.getJcaName());
 
-    public String generateRefreshToken(String email) {
-        return generateToken(email, refreshTokenExpireTime);
+        byte[] refreshDecodedKey = Base64.getDecoder().decode(rSecret);
+        this.hmacRefreshKey = new SecretKeySpec(refreshDecodedKey, SignatureAlgorithm.HS256.getJcaName());
     }
 
-    private String generateToken(String email, Long expireTime) {
+    private String generateToken(String email, Long expireTime, Key key) {
         Date now = new Date();
         Date expiryDate = new Date(now.getTime() + expireTime);
         return Jwts.builder().setSubject(email)
                 .setIssuedAt(now)
                 .setExpiration(expiryDate)
-                .signWith(hmacKey)
+                .signWith(key)
                 .compact();
     }
 
-    public String getEmailFromToken(String token) {
-        Claims claims = Jwts.parserBuilder()
-                .setSigningKey(hmacKey)
+    public String generateAccessToken(String email) {
+        return generateToken(email, accessTokenExpireTime, hmacAccessKey);
+    }
+
+    public String generateRefreshToken(String email) {
+        return generateToken(email, refreshTokenExpireTime, hmacRefreshKey);
+    }
+
+    public String generateTestToken(String email, Long expireTime) {
+        return generateToken(email, expireTime, hmacAccessKey);
+    }
+
+    private Claims getAllClaimsFromToken(String token, Key key) {
+        return Jwts.parserBuilder()
+                .setSigningKey(key)
                 .build()
                 .parseClaimsJws(token)
                 .getBody();
+    }
+
+    public Date getExpirationDateFromAccessToken(String token) {
+        return getAllClaimsFromToken(token, hmacAccessKey).getExpiration();
+    }
+
+    public Date getExpirationDateFromRefreshToken(String token) {
+        return getAllClaimsFromToken(token, hmacRefreshKey).getExpiration();
+    }
 
-        return claims.getSubject();
+    public String getEmailFromAccessToken(String token) {
+        return getAllClaimsFromToken(token, hmacAccessKey).getSubject();
     }
 
     public void validateToken(String token) {
         try {
             Jwts.parserBuilder()
-                    .setSigningKey(hmacKey)
+                    .setSigningKey(hmacAccessKey)
                     .build()
                     .parseClaimsJws(token);
         } catch (ExpiredJwtException e) {