JWT 인증 및 토큰 기반 인증 시스템 정리

 

🎯 목표

1. 세션 방식과 JWT 방식의 차이점 명확히 이해
2. JWT 인증 구조와 Access Token, Refresh Token 사용법 심층 학습

---

✅ 핵심 개념 및 정의

용어 설명

세션 방식	서버가 클라이언트별로 세션 정보를 저장하고 식별하는 방식
JWT (JSON Web Token)	자가 수용적(self-contained) 정보 전송 토큰, 클라이언트가 직접 인증 정보를 보유
Access Token	보호된 자원 접근을 위한 단기 사용 토큰 (주로 15~30분)
Refresh Token	Access Token 만료 시 재발급을 위한 장기 사용 토큰 (주로 14~30일)
토큰 저장소	Redis, DB 등에서 Refresh Token을 저장하고 관리하는 시스템

---

🔍 세션 방식 vs JWT 방식

세션 방식

• 서버가 세션 ID를 생성하고 클라이언트 쿠키에 저장 (ex: JSESSIONID)
• 서버 메모리나 별도 DB에 세션 데이터 관리 필요
• 서버 확장(Scale-out) 시 세션 클러스터링 또는 Sticky Session 필요
• 세션 유지를 위해 서버 상태(Stateful) 필요
• 사용자 정보와 인증 상태를 서버가 직접 관리

JWT 방식

• 서버는 로그인 시 토큰만 발급하고 이후 상태를 저장하지 않음 (Stateless)
• 클라이언트가 JWT를 저장하고 매 요청마다 Authorization 헤더에 포함하여 전송
• 서버는 JWT의 서명(Signature)만 검증하여 신뢰성 확보
• 서버 확장에 유리하며, 마이크로서비스 아키텍처와 잘 맞음
• 토큰 탈취 시 만료까지 취소가 어려워 별도의 무효화 전략 필요

---

🔍 Access Token + Refresh Token 인증 흐름

1. 로그인 성공

• 서버: 인증 완료 후 Access Token (30분), Refresh Token (14일) 발급
• 클라이언트:
  • Access Token은 메모리에 저장 후 Authorization 헤더로 전송
  • Refresh Token은 HttpOnly, Secure 속성이 적용된 쿠키에 저장

2. API 요청

• 모든 보호된 API 요청 시 Authorization: Bearer {Access Token} 헤더 포함

3. Access Token 만료

• 서버: 401 Unauthorized 반환
• 클라이언트: 저장된 Refresh Token을 이용해 새 Access Token 발급 요청
• 서버: Redis에서 Refresh Token 검증 후 새 Access Token 재발급

4. 로그아웃

• 서버: Redis에서 해당 Refresh Token 삭제
• 클라이언트: 메모리와 쿠키에서 각각 Access Token과 Refresh Token 삭제

---

🛠프로젝트 인증 시스템 실제 코드 예시

JwtService.java

@Service
@RequiredArgsConstructor
public class JwtService {
    private final RedisTemplate<String, String> redisTemplate;

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.access-token-validity-in-seconds}")
    private long accessTokenValidity;

    @Value("${jwt.refresh-token-validity-in-seconds}")
    private long refreshTokenValidity;

    public String createAccessToken(Long userId, String email, MemberRole role) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("id", userId);
        claims.put("email", email);
        claims.put("role", role.name());

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + accessTokenValidity * 1000))
                .signWith(getSignKey(), SignatureAlgorithm.HS256)
                .compact();
    }

    public String createRefreshToken(Long userId) {
        String refreshToken = Jwts.builder()
                .setSubject(userId.toString())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + refreshTokenValidity * 1000))
                .signWith(getSignKey(), SignatureAlgorithm.HS256)
                .compact();

        redisTemplate.opsForValue().set(
                "RT:" + userId,
                refreshToken,
                refreshTokenValidity,
                TimeUnit.SECONDS
        );

        return refreshToken;
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(getSignKey())
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public Long getUserIdFromToken(String token) {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(getSignKey())
                .build()
                .parseClaimsJws(token)
                .getBody();

        return Long.parseLong(claims.get("id").toString());
    }

    public String refreshAccessToken(String refreshToken) {
        try {
            Claims claims = Jwts.parserBuilder()
                    .setSigningKey(getSignKey())
                    .build()
                    .parseClaimsJws(refreshToken)
                    .getBody();

            Long userId = Long.parseLong(claims.getSubject());

            String storedRefreshToken = redisTemplate.opsForValue().get("RT:" + userId);

            if (storedRefreshToken == null || !storedRefreshToken.equals(refreshToken)) {
                throw new IllegalArgumentException("Invalid refresh token");
            }

            // 사용자 정보 조회 로직 필요 (예: UserRepository)
            User user = userRepository.findById(userId)
                    .orElseThrow(() -> new UsernameNotFoundException("User not found"));

            return createAccessToken(user.getId(), user.getEmail(), user.getRole());

        } catch (Exception e) {
            throw new IllegalArgumentException("Failed to refresh token", e);
        }
    }

    public void logout(Long userId) {
        redisTemplate.delete("RT:" + userId);
    }

    private Key getSignKey() {
        byte[] keyBytes = Decoders.BASE64.decode(secret);
        return Keys.hmacShaKeyFor(keyBytes);
    }
}

AuthController.java

@RestController
@RequestMapping("/api/auth")
@RequiredArgsConstructor
public class AuthController {
    private final AuthService authService;
    private final JwtService jwtService;

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest request, HttpServletResponse response) {
        User user = authService.authenticate(request.getEmail(), request.getPassword());

        String accessToken = jwtService.createAccessToken(user.getId(), user.getEmail(), user.getRole());
        String refreshToken = jwtService.createRefreshToken(user.getId());

        Cookie refreshTokenCookie = new Cookie("refresh_token", refreshToken);
        refreshTokenCookie.setHttpOnly(true);
        refreshTokenCookie.setSecure(true);
        refreshTokenCookie.setPath("/");
        refreshTokenCookie.setMaxAge((int) jwtService.getRefreshTokenValidity());
        response.addCookie(refreshTokenCookie);

        Map<String, Object> responseBody = new HashMap<>();
        responseBody.put("accessToken", accessToken);
        responseBody.put("user", UserDto.from(user));

        return ResponseEntity.ok(responseBody);
    }

    @PostMapping("/refresh")
    public ResponseEntity<?> refreshToken(@CookieValue(name = "refresh_token", required = false) String refreshToken) {
        if (refreshToken == null) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Refresh token is missing");
        }

        try {
            String newAccessToken = jwtService.refreshAccessToken(refreshToken);
            Map<String, String> response = new HashMap<>();
            response.put("accessToken", newAccessToken);
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid refresh token");
        }
    }

    @PostMapping("/logout")
    public ResponseEntity<?> logout(@RequestHeader("Authorization") String authHeader, HttpServletResponse response) {
        String token = authHeader.replace("Bearer ", "");
        Long userId = jwtService.getUserIdFromToken(token);

        jwtService.logout(userId);

        Cookie refreshTokenCookie = new Cookie("refresh_token", null);
        refreshTokenCookie.setMaxAge(0);
        refreshTokenCookie.setPath("/");
        response.addCookie(refreshTokenCookie);

        return ResponseEntity.ok().body("Successfully logged out");
    }
}

RedisConfig.java

@Configuration
@EnableRedisRepositories
public class RedisConfig {
    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(redisHost, redisPort);
        return new LettuceConnectionFactory(redisConfig);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate() {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

---

🚧 보안 고려사항

• Access Token은 메모리에만 저장하여 XSS 위험 최소화
• Refresh Token은 HttpOnly, Secure 쿠키로 보호
• Refresh Token Rotation 기법 적용 (재발급 시 새 토큰 발급)
• HTTPS 필수 적용 (Access/Refresh Token 모두 암호화된 채널로 전송)
• JWT 클레임 필수 검증 (exp, iat, iss 등)

---

⚠️ 흔한 이슈와 해결 방법

이슈 원인 해결 방법

토큰 탈취	XSS 공격으로 토큰 노출	HttpOnly 쿠키 사용 및 CSP(Content Security Policy) 설정
CSRF 공격	쿠키 자동 전송 악용	SameSite=Strict 설정, CSRF 토큰 추가
토큰 만료 처리 복잡	Access Token 만료 후 자동 재요청 필요	Axios Interceptor를 통한 자동 갱신 처리
Refresh Token 탈취	Refresh Token 관리 부주의	Rotation 적용 및 재발급 시 교체 필수

---

💡 학습 정리

• 세션 방식은 서버 상태 저장 필요, JWT는 완전 Stateless 인증 가능
• Access Token은 짧은 유효기간, Refresh Token은 긴 유효기간 설정
• Redis에는 Refresh Token만 저장하여 시스템 부하 최소화
• Rotation 전략을 통해 Refresh Token 갱신 및 보안성 향상
• 다층 보안 적용 (XSS, CSRF, HTTPS, 토큰 서명 검증)으로 인증 시스템 강화