JWT 인증∙인가 구현하기

JWT란

JWT(JSON Web Token)란? | JWT 구성요소
토큰이 필요한 이유와 JWT 동작 방식

인증, 인가 흐름(+클래스 다이어그램)

JwtProvider 구현

JwtProvider는 Jwt를 생성, 파싱, 검증하는 클래스다.
구현엔 jjwt 라이브러리를 사용했다.

jwt 관련 정보인 secret, expire-length를 application.yml에 다음과 같이 설정했다.

jwt:
  header: Authorization
  secret: (특정 문자열을 Base64로 인코딩한 값)
  access-token:
    expire-length: 3600
  refresh-token:
    expire-length: 86400

private final Key key;

@Value("${jwt.access-token.expire-length}")
private long accessTokenExpireLengthInSeconds;

@Value("${jwt.refresh-token.expire-length}")
private long refreshTokenExpireLengthInSeconds;

public JwtProvider(
    @Value("${jwt.secret}") String secret) {
    byte[] keyBytes = Decoders.BASE64.decode(secret);
    this.key = Keys.hmacShaKeyFor(keyBytes);
}

Jwts.builder로 토큰을 생성하고 Jwts.parseBuilder와 parseClaimJws로 claims를 파싱할 수 있다.

public Jwt createJwt(Map<String, Object> claims) {
    String accessToken = createToken(claims, getExpireDateAccessToken());
    String refreshToken = createToken(new HashMap<>(), getExpireDateRefreshToken());
    return Jwt.builder()
        .accessToken(accessToken)
        .refreshToken(refreshToken)
        .build();
}

public String createToken(Map<String, Object> claims, Date expireDate) {
    return Jwts.builder()
        .setClaims(claims)
        .setExpiration(expireDate)
        .signWith(key, SignatureAlgorithm.HS256)
        .compact();
}

public Claims getClaims(String token) {
    return Jwts.parserBuilder()
        .setSigningKey(key)
        .build()
        .parseClaimsJws(token)
        .getBody();
}

Jwt 클래스는 access token과 refresh token 필드로 구성되어 있습니다.

//Jwt.java
@Getter
public class Jwt {

    private String accessToken;
    private String refreshToken;

    @Builder
    public Jwt(String accessToken, String refreshToken) {
        this.accessToken = accessToken;
        this.refreshToken = refreshToken;
    }
}

로그인 구현

로그인에 성공하면 토큰을 응답으로 반환합니다.

//UserController.java
@PostMapping("/users/sign-in")
public ResponseEntity<ApiResponse<Jwt>> signIn(@Valid @RequestBody UserLoginDto loginDto) 
    throws JsonProcessingException {
    Jwt jwt = usersService.signIn(loginDto);
    return ResponseEntity.ok(success(SuccessCode.GET_SUCCESS, jwt));
}

//UserService.java
@Transactional
public Jwt signIn(UserLoginDto loginDto) throws JsonProcessingException {

    // db에 있는(회원가입한) 유저인지 검증
    Users user = usersRepository.findByTel(loginDto.getTel())
        .orElseThrow(() -> new IllegalArgumentException("회원가입하지 않은 유저입니다."));

    // 비밀번호 검증
    if (!loginDto.getPassword().equals(user.getPassword())) {
        throw new IllegalArgumentException("비밀번호가 일치하지 않습니다.");
    }

    // 토큰 생성
    Jwt jwt = authService.createJwt(user);

    // refreshToken 저장
    user.updateRefreshToken(jwt.getRefreshToken());

    return jwt;
}

//AuthService.java
public Jwt createJwt(Users user) throws JsonProcessingException {

    // claims 생성
    Map<String, Object> claims = new HashMap<>();
    AuthenticateUser authenticateUser = new AuthenticateUser(user);
    String authenticateUserJson = objectMapper.writeValueAsString(authenticateUser);
    claims.put(AUTHENTICATE_USER, authenticateUserJson);

    // 토큰 생성
    return jwtProvider.createJwt(claims);
}

필터를 통한 토큰 유효성 검증 기능 구현

페이지 접근 요청 시, 토큰이 유효한 경우만 접근을 허용하는 필터를 구현하겠습니다.

인가 처리가 필요하지 않은 요청에 대해선 토큰 유효성을 검증하지 않도록 whiteListUris를 작성했습니다.

resolveToken으로 request header의 Authorization에 담긴 accessToken을 가져옵니다.

validateToken으로 accessToken의 유효성을 검증합니다.
유효한 토큰이면 userId, role 정보를 request의 attribute로 추가합니다.
request header에 토큰이 없거나, 유효하지 않은 토큰이면 401 UNAUTHORIZED 응답을 보냅니다.

@RequiredArgsConstructor
@Component
public class JwtValidationFilter implements Filter {

    private final JwtProvider jwtProvider;
    private final ObjectMapper objectMapper;

    private final String[] whiteListUris
        = new String[] {"*/users*", "/auth/refresh/token", "*/h2-console*"};

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws
        IOException, ServletException {

        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;

        // 토큰 유효성을 검증하지 않아도 되는 경우
        if (whiteListCheck(httpServletRequest.getRequestURI())) {
            chain.doFilter(request, response);
            return;
        }

        // 요청 헤더에 토큰이 없는 경우
        if (!isContainToken(httpServletRequest)) {
            httpServletResponse.sendError(HttpStatus.UNAUTHORIZED.value(), "인증 오류");
            return;
        }

        String accessToken = jwtProvider.resolveToken(httpServletRequest);
        JwtExceptionType jwtException = jwtProvider.validateToken(accessToken);

        if (jwtException == JwtExceptionType.VALID_JWT_TOKEN) {
            request.setAttribute(AUTHENTICATE_USER, getAuthenticateUser(accessToken));
        } else if (jwtException == JwtExceptionType.EXPIRED_JWT_TOKEN) {
            httpServletResponse.sendError(HttpStatus.UNAUTHORIZED.value(), "토큰 만료");
            return;
        }

        chain.doFilter(request, response);
    }

    private boolean whiteListCheck(String uri) {
        return PatternMatchUtils.simpleMatch(whiteListUris, uri);
    }

    private boolean isContainToken(HttpServletRequest request) {
        String authorization = request.getHeader(AUTHORIZATION_HEADER);
        return authorization != null && authorization.startsWith(BEARER_TOKEN_PREFIX);
    }

    private AuthenticateUser getAuthenticateUser(String token) throws JsonProcessingException {
        Claims claims = jwtProvider.getClaims(token);
        String authenticateUserJson = claims.get(AUTHENTICATE_USER, String.class);
        return objectMapper.readValue(authenticateUserJson, AuthenticateUser.class);
    }
}

// JwtProvider.java
// Request Header에서 token 값 가져옴
public String resolveToken(HttpServletRequest request) {
    String header = request.getHeader(AUTHORIZATION_HEADER);
    return header.split(" ")[1];
}

// jwt 유효성 검사
public JwtExceptionType validateToken(String token) {
    try {
        getClaims(token);
        return JwtExceptionType.VALID_JWT_TOKEN;
    } catch (SignatureException exception) {
        log.info("JWT 서명이 유효하지 않습니다");
        return JwtExceptionType.INVALID_JWT_SIGNATURE;
    } catch (MalformedJwtException exception) {
        log.info("JWT가 올바르게 구성되지 않았습니다.");
        return JwtExceptionType.INVALID_JWT_TOKEN;
    } catch (ExpiredJwtException exception) {
        log.info("만료된 토큰입니다.");
        return JwtExceptionType.EXPIRED_JWT_TOKEN;
    } catch (UnsupportedJwtException exception) {
        log.info("지원되지 않는 형식의 토큰입니다.");
        return JwtExceptionType.UNSUPPORTED_JWT_TOKEN;
    } catch (IllegalArgumentException exception) {
        log.info("JWT Claim이 비어있습니다.");
        return JwtExceptionType.EMPTY_JWT;
    }
}

이렇게 생성한 필터는 FilterRegistrationBean을 통해 등록해야 동작합니다.
FilterRegisterationBean를 등록하기 위한 WebConfig라는 Configuration 클래스를 생성했습니다.
setFilter로 filter를 등록하고 setOrder로 순서를 지정했습니다.

@Configuration
public class WebConfig {

    @Bean
    public FilterRegistrationBean<Filter> jwtValidationFilter(JwtProvider jwtProvider, ObjectMapper objectMapper) {
        FilterRegistrationBean<Filter> filterFilterRegistrationBean = new FilterRegistrationBean<>();
        filterFilterRegistrationBean.setFilter(new JwtValidationFilter(jwtProvider, objectMapper));
        filterFilterRegistrationBean.setOrder(1);
        return filterFilterRegistrationBean;
    }
}

인터셉터를 통한 인가 기능 구현

토큰 유효성 검증은 특정 요청, 컨트롤러에 관계없이 전역적으로 처리해야 하는 작업이므로 필터로 구현했습니다.

반면 특정 url에 대한 인가 기능은 클라이언트의 요청과 관련되어 전역적으로 처리해야 하는 작업들이므로 인터셉터로 구현했습니다.

유저는 ADMIN, CUSTOMER, DRIVER 중 하나의 권한을 가집니다.
이때 고객 권한을 가진 유저는 기사 페이지에 접근 할 수 없으며, 기사 권한을 가진 유저는 고객 페이지에 접근할 수 없습니다.

이와 같은 인가를 처리하는 UserAuthorizationInterceptor를 작성했습니다.

토큰 유효성이 검증된 유저에 한해서 인가 처리를 진행합니다.
요청한 url이 없는 경우 404 NOT FOUND를 응답합니다.

hasAuthority로 유저 role에 따른 컨트롤러 접근 권한을 확인합니다.
접근 권한이 있다면 다음 인터셉터나 컨트롤러를 실행합니다.
접근 권한이 없다면 401 UNAUTHORIZED 응답을 반환합니다.

public class UserAuthorizationInterceptor implements HandlerInterceptor {

    private static final String CUSTOMER_URL = "/reservations";
    private static final String DRIVER_URL = "/orders";

    @Override
    public boolean preHandle(HttpServletRequest request, @Nonnull HttpServletResponse response, @Nonnull Object handler)
        throws IOException {
        if (request.getAttribute(AUTHENTICATE_USER) != null) {
            AuthenticateUser authenticateUser = (AuthenticateUser)request.getAttribute(AUTHENTICATE_USER);
            Role role = authenticateUser.getRole();
            String baseUrl = getBaseUrl(handler);

            if (baseUrl == null) {
                response.sendError(HttpStatus.NOT_FOUND.value(), "요청한 페이지를 찾을 수 없음");
                return false;
            }

            // url에 대한 접근 권한 확인
            if (hasAuthority(baseUrl, role)) {
                return true;
            }
        }
        response.sendError(HttpStatus.UNAUTHORIZED.value(), "엑세스 권한 없음");
        return false;
    }

    private static String getBaseUrl(Object handler) {
        if (handler instanceof HandlerMethod handlerMethod) { //호출할 컨트롤러 메서드의 모든 정보가 포함되어 있음
            return handlerMethod.getMethod().getDeclaringClass().getAnnotation(RequestMapping.class).value()[0];
        }
        return null;
    }

    private boolean hasAuthority(String url, Role role) {
        if ((role.equals(Role.CUSTOMER) && url.endsWith(DRIVER_URL))
            || (role.equals(Role.DRIVER) && url.endsWith(CUSTOMER_URL))) {
            return false;
        }
        return true;
    }
}

이렇게 생성한 인터셉터는 InterceptorRegistry를 통해 등록해야 동작합니다.
WebConfig에 InterceptorRegistry.addInterceptor로 인터셉터를 등록했습니다.
회원가입/로그인은 jwt 발급 전에 수행되는 작업이므로 excludePathPatterns로 인가 처리에서 제외했습니다.

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserAuthorizationInterceptor())
            .order(1)
            .excludePathPatterns("/api/v1/users/**", "*/h2-console*", "/css/**", "/*.ico", "/error");
    }
}

---

• (필수) 예외처리 해야함
• (선택) 리프레시 토큰 발급 / 로그아웃 구현할지 얘기해봐야함
• 구현하고 나니까 비회원은 어떻게 처리해야하나 싶은데 비회원이 접근하는 url만 인증, 인가 안 하면 될 것 같기도 하고