왜 JWT를 선택 하였는가?

쿠키

---

• 클라이언트에 300개 까지 저장 가능, 도메인당 20개의 값 가질 수 있다.

• 쿠키는 사용자가 요청하지 않아도, 브라우저가 Request 시에 Request Header를 넣어 자동으로 서버에 전송한다.

• 기존에는 쿠키에 사용자의 인증 정보를 담아서 보내는 방식 사용
  • 문제점 : 사용자의 인증 정보가 탈취될 가능성이 있다.

세션

---

• 서버에서 클라이언트를 구분하기 위해 세션 ID를 부여한다.

• 해당 세션을 서버측에서 관리하며, 사용자는 쿠키에 세션정보를 담아 보내면 서버에서 유효한 사용자인지 판단한다.

• 장점
  • 데이터가 서버에 있기 때문에, 세션이 탈취당해도 사용자의 인증정보는 안전할 수 있다.

• 단점
  • 사용자가 많아질수록 서버 메모리를 많이 차지하게 된다.
  • 서버가 여러개인 환경에서 세션을 동기화 시킬 때, 추가적인 시간이 소요된다.

• 해결방안
  • 레디스를 활용하여 하나의 서버에서 세션을 관리한다.
  • 로드밸런싱을 통해 특정 IP에서 들어오는 요청은, 특정 서버로만 갈 수 있도록 한다.

JWT

---

• 구성
  • Header, Payload, Signature

• 생성 과정
  1. Header에 Signature 해싱에 사용할 알고리즘 방식을 지정하여 토큰 검증에 사용
  2. Payload에 사용자의 정보 및 토큰 만료 기한 적음
  3. Header와 Payload를 각각 BASE64로 인코딩
  4. Secret Key로 헤더에서 정의한 알고리즘을 통해 해싱 한다
  5. 위 값을 다시 BASE64로 인코딩 하여 생성한다

• 문제점
  • 토큰이 탈취 당하면, 만료기한 전까지 탈취당한 토큰이 악용당할 수 있다.
  • 토큰 탈취 시나리오를 생각하면, 토큰의 유효시간을 짧게 설정 해야 한다.
  • 토큰의 유효시간이 짧을 경우 사용자는 계속 재로그인을 해야하는 불편함이 생긴다.

• 해결방안
  • Access Token + Refresh Token 같이 사용
  • 인가를 담당하는 Access Token은 기간을 짧게 설정하고
  • 재발급을 담당하는 Refresh Token은 기간을 길게 설정할 수 있다.

• 토큰 보관 방법
  • Access Token
    • 단독 사용 : 브라우저의 세션 스토리지에 저장
    • 세션 스토리지의 문제점 - JS로 토큰 값을 꺼내서 보내는 방식이기 때문에, XSS에 취약
    • Refresh Token과 함께 사용
      • 쿠키에 담을 때 : Refresh Token도 쿠키에 담기 때문에, Refresh Token과 함께 같이 탈취당할 수 있다.
      • 대안 : 자바 스크립트의 private 변수로 저장해 둔다.
        • 예상 문제점 - 페이지 이동시 마다 재발급 필요하지 않는가?
        • 해결방안 1. Redis를 활용하여 토큰의 발급 속도를 향상 시킨다.
        • 해결방안 2. React, Vue 처럼 SPA를 활용하여 페이지 이동 없이 토큰 만료시에만 재발급 할 수 있다.
  • Refresh Token
    • 쿠키에 보관 : 쿠키도 JS로 접근 가능하기 때문에, HTTP Only 옵션과 HTTPS가 적용되지 않은 이미지 등으로 탈취 되는것을 방지하기 위해 Secure 옵션을 설정해준다.

    💡

    Refresh Token을 발급만 해주면 보안상으로 문제가 없는 것인가?

    • 그렇지 않다!!!!
    • 토큰 탈취 시나리오
      1. 쿠키에 담긴 Refresh Token 탈취
      2. 기존 사용자는 Access Token 활용 및 추후 만료시 Refresh Token으로 재발급 요청
      3. 해커는 탈취한 Refresh Token으로 Access Token 재발급
      4. Refresh Token은 만료 기한이 길기 때문에, 만료기간 도달까지 해커는 Refresh Token으로 Access Token 재발급 받아 사용할 수 있음.
      5. 하나의 Refresh Token으로 두명이 사용하는 문제가 생김
    • 대안
      • Refresh Token Rotation 도입
        • 새로운 Access token 발급 요청이 들어올 때 마다, 리프레시 토큰을 교체하는 방식
        • 이 경우 Refresh Token은 하나에 한개의 토큰만 발급할 수 있게 된다.
        • 토큰 탈취 시나리오
          1. 쿠키에 담긴 Refresh Token 탈취
          2. Refresh Token 사용해서 재발급 요청 - 사용된 Refresh Token을 DB에 저장
             • 사용자가 요청할 경우 : Access + Refresh Token을 사용자에게 재발급
             • 해커가 요청할 경우 : Access + Refresh Token을 해커에게 재발급
          3. 추후 사용자 또는, 해커가 이미 사용된 Refresh Token으로 재발급 요청
          4. 재발급 요청이 들어올 경우 해당 사용자와 관련된 모든 Refresh Token을 Invalid 상태로 만듬.
          5. 이후 해커의 Refresh Token은 사용 불가능 상태가 되고, 사용자는 재로그인을 통해 Refresh Token과 Access Token을 다시 발급 받을 수 있음.
        •  

Spring Security를 활용한 JWT 구현

 

TokenInfo

---

@Builder
@Data
@AllArgsConstructor
public class TokenInfo {
    private String grantType;
    private String accessToken;
    private String refreshToken;
}

• Builder 패턴을 적용하였다.

• @Data는 지양하는 것이 좋지만, 개발 편의성을 위해 우선 사용하였다.

JwtTokenProvider

---

@Slf4j
@Component
public class JwtTokenProvider {


    private Key secret;
    @Value("${jwt.access-expired}")
    private Long accessTokenExpired;
    @Value("${jwt.refresh-expired}")
    private Long refreshTokenExpired;

    public JwtTokenProvider(@Value("${jwt.secret}") String secret) {
        byte[] keyBytes = secret.getBytes();
        this.secret = Keys.hmacShaKeyFor(keyBytes);
    }

    /**
     * 유저 정보를 통해 토큰 생성
     */
    public TokenInfo generateToken(Authentication authentication) {
        log.info("generateToken start");

        long now = (new Date()).getTime();
        Date accessTokenExpiresIn = new Date(now + (1000 * accessTokenExpired)); // 30분
        Date refreshTokenExpiresIn = new Date(now + (1000 * refreshTokenExpired)); // 14일

        String accessToken = Jwts.builder()
            .setSubject(authentication.getName())
            .claim("auth", "USER")
            .setExpiration(accessTokenExpiresIn)
            .signWith(secret, SignatureAlgorithm.HS256)
            .compact();

        log.info(parseClaims(accessToken).toString());

        String refreshToken = Jwts.builder()
            .setExpiration(refreshTokenExpiresIn)
            .signWith(secret, SignatureAlgorithm.HS256)
            .compact();

        log.info("accessToken: {}", accessToken);
        return TokenInfo.builder()
                .grantType("Bearer")
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build();
    }

    /**
     * 토큰에서 유저 정보 추출
     */
    public Authentication getAuthentication(String accessToken) {
        Claims claims = parseClaims(accessToken);

        if (claims.get("auth") == null) {
            throw new RuntimeException("권한 정보가 없는 토큰입니다.");
        }
        log.info("claims: {}", claims);
        Collection<? extends GrantedAuthority> authorities =
            Arrays.stream(claims.get("auth").toString().split(","))
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());

        log.info("authorities: {}", authorities);
        UserDetails principal = new User(claims.getSubject(), "", authorities);
        return new UsernamePasswordAuthenticationToken(principal, "", authorities);
    }

    /**
     * 토큰 정보 검증
     */
    public boolean validateToken(String token) {
        log.info("validateToken start");
        log.info("token: {}", token);
        try {
            Jwts.parserBuilder().setSigningKey(secret).build().parseClaimsJws(token);
            return true;
        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) {
            log.info("Invalid JWT Token", e);
        } catch (ExpiredJwtException e) {
            // refresh token 활용해서 재발급
            log.info("Expired JWT Token", e);
            throw e;
        } catch (UnsupportedJwtException e) {
            log.info("Unsupported JWT Token", e);
        } catch (IllegalArgumentException e) {
            log.info("JWT claims string is empty.", e);
        }
        return false;
    }

    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder()
               .setSigningKey(secret)
               .build()
               .parseClaimsJws(accessToken)
               .getBody();
        } catch (ExpiredJwtException e) {
            return e.getClaims();
        }
    }

    public String getMemberEmail(String refreshToken) {
        Claims claims = Jwts.parserBuilder()
            .setSigningKey(secret)
            .build()
            .parseClaimsJws(refreshToken)
            .getBody();
        return claims.getSubject();
    }
}

• generateToken : 만들어진 authentication을 활용해서 TokenInfo을 만든다

• getAuthentication : accessToken을 확인하고 인증 정보를 반환해준다.

• validateToken : 토큰의 valid를 검증한다.
  • 각 Exception들은 RuntimeError를 상속하고 있는데, ExpiredJwtException은 추후 accessToken 만료 시나리오에서 쓰이기 때문에 catch 하지 않고 throw 해준다.

• getClaims : 클레임을 반환한다.

 

JwtAuthenticationFilter

---

@Slf4j
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Value("${jwt.secret}")
    private String secret;
    private final JwtTokenProvider jwtTokenProvider;
    private final ObjectMapper objectMapper;
    private static final String BEARER = "Bearer ";
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
        log.info("doFilterInternal start");
        String authorization = request.getHeader(HttpHeaders.AUTHORIZATION);

        // access token이 있고, BEARER로 시작한다면
        if (authorization != null && authorization.startsWith(BEARER)) {
            String token = authorization.substring(BEARER.length());
            log.info("token: {}", token);
            // token을 검증한다.
            try {
                if (jwtTokenProvider.validateToken(token)) {
                    // token이 유효하다면
                    // token으로부터 유저 정보를 받아온다.
                    Authentication authentication = jwtTokenProvider.getAuthentication(token);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            } catch (ExpiredJwtException e) {
                log.info("ExpiredJwtException");
                // access token이 만료되었다면
                // 에러를 보낸다
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                Map<String, String> error = new HashMap<>();
                error.put("message", "access token expired");
                error.put("code", "401");
                error.put("status", "UNAUTHORIZED");
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().write(objectMapper.writeValueAsString(error));
                return;
            }

        }

        filterChain.doFilter(request, response);
    }
}

• OncePerRequestFilter 🆚 GenericFilterBean
  • GenericFilterBean : 매 서블릿 마다 호출된다
  • OncePerRequestFilter : RequestDispatcher 클래스에 의해 다른 서블릿으로 dispatch 되더라도, Filter가 실행되지 않는다.
  • 추후 Oauth 구현을 위해 OncePerRequestFilter로 설정하였다.

• doFilterInternal
  • Header에서 Authorization을 활용해 accessToken을 검증한다
  • 엑세스 토큰이 만료되었을 경우 Exception을 캐치하여 response에 에러 메세지를 반환해준다
  • 엑세스 토큰이 정상적일 경우, SecurityContextHolder에 Authenticaton을 가져와 설정해준다.
  • 엑세스 토큰이 없을 경우 설정 없이 필터 체인을 거치게 된다.

 

SecurityConfig

---

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtTokenProvider jwtTokenProvider;
    private final ObjectMapper objectMapper;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .httpBasic().disable()
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
            .antMatchers("/login/member").permitAll() // 해당 API 모든 요청 허가
            .antMatchers("/login/token/reissue").permitAll() // 해당 API 모든 요청 허가
            .antMatchers("/login/test").authenticated()
//            .anyRequest().authenticated()
            .and()
            .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider, objectMapper), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    // 그 외 나머지 요청은 인증 필요
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

}

• passwordEncoder : 단방향 암호화 문제를 해결하기 위한 팩토리패턴을 활용해 빈으로 등록하였다. 추후 암호화 알고리즘 변경시에도 적용하기 좋다

• Config를 통해 필터체인을 등록한다. 이때 내가 만든 JwtAuthenticationFilter 가 시큐리티보다 먼저 적용될 수 있도록 해야한다.

• Cors 정책으로 인해 HTTP OPTIONS는 모두 허용 해주었다.

• /login/member, /login/token/reissue는 권한이 없는 사용자의 요청이므로, 해당 요청에 대해서는 모든 요청을 허락 해주어야 한다.

• /login/test 요청은 authenticated를 통해 인가 확인하고 실행하도록 한다

 

 

 

Spring Controller, Service, Repository 구현

LoginMemberController

---

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/login")
public class LoginMemberController {

    @Value("${cors.frontend}")
    private String referer;

    private Long refreshTokenExpired;

    private final LoginMemberService loginMemberService;

    @PostMapping("/member")
    public TokenInfo loginTest(@RequestBody LoginMemberRequestDto loginMemberRequestDto
        , HttpServletResponse response) throws IOException {
        log.info("memberLoginRequestDto: {}", loginMemberRequestDto);
        TokenInfo token = loginMemberService.login(loginMemberRequestDto);
        log.info("token: {}", token);
        Cookie refreshToken = new Cookie("refreshToken", token.getRefreshToken());
        response.setHeader("Set-Cookie",
            "refreshToken=" + token.getRefreshToken() + "; Path=/; HttpOnly; Secure; Max-Age=" + refreshTokenExpired);
        return token;
    }

    @PostMapping("/test")
    public String test() {
        return "test";
    }

    @GetMapping("/token/reissue")
    public Object reissueAccessToken(HttpServletRequest request, HttpServletResponse response) throws IOException {

        log.info("reissueAccessToken start");
        Cookie refreshToken = WebUtils.getCookie(request, "refreshToken");
        log.info("refreshToken: {}", refreshToken);
        Object responseJson = loginMemberService.reissue(refreshToken.getValue());
        log.info("tokenInfo: {}", responseJson);
        if (responseJson instanceof TokenInfo) {
            TokenInfo tokenInfo = (TokenInfo) responseJson;
            response.setHeader("Set-Cookie",
                "refreshToken=" + tokenInfo.getRefreshToken() + "; Path=/; HttpOnly; Secure; Max-Age=" + refreshTokenExpired);
        }
        return responseJson;
    }


}