[Spring Security] JWT + OAuth2.0 적용해보기 - (1)

spring security 학습과 Spring boot 에  JWT, OAuth2.0  적용을 위해 간단한 프로젝트를 진행해 보았습니다. 이번 프로젝트로 filter 기반의 Spring Security 아키텍처를 이해하고, JWT 와 OAuth2.0 의 이해 및 적용을 목표로 하였습니다.

 

JWT 기반 인증

이번 프로젝트는 access token 과 refresh token 을 모두 사용하는 방법을 채택했습니다. access token 과 refresh token 을 사용한 flow 는 다음과 같습니다. 

AT :  Access Token. 만료기간 짧음, RT : Refresh Token. 만료기간 김

case 0 ) login

/login

• 로그인 성공 시, 200 - memberId, AT1, RT1 response. RT1 은 cookie 에 세팅된다.
• 로그인 실패 시, 401 - 인증 실패 error response

 

case 1)  AT1 만료 X

/request with AT1

• Authorization header 에 Bearer AT1 을 첨부하여 request 한다.
• AT1 검증 후 정상적으로 response

 

case 2)  AT1 만료, RT1 만료 X

/request with AT1

• Authorization header 에 Bearer  AT1 을 첨부하여 request 한다.
• 401 - token 만료 error response
• client 는 token 이 만료되었다는 response 확인 후 Authorization header 에 Bearer RT1 첨부하여 request 한다.

/refresh with RT1

• RT1 검증 후 AT2 response

 

case 3) AT1 만료, RT1 만료

/request with AT1

• 401 - token 만료 error response
• client 는 token 이 만료되었다는 response 확인 후 Authorization header 에 Bearer RT1 첨부하여 request 한다.

/refresh with RT1

• 401 - token 만료 error response
• RT1 이 만료되었다는 것을 확인했으므로, client 는 /login 을 통해 새로운 AT 와 RT 를 받아야 한다.

간단한 구현을 위해 refresh token 의 갱신 주기는 고려하지 않았지만, refresh token 에 갱신 주기를 추가하여 인증 과정을 설계할 수도 있습니다.

 

Spring Security 에서의 인증 과정

spring security 를 사용한 인증과정에서의 핵심은 AuthenticationManager 인터페이스 입니다. AuthenticationManager 의 authenticate 메서드는 Authentication 객체를 인자로 받아 인증을 시도합니다. 인증이 성공하면 권한을 포함한 인증된 Authentication 객체를 return 하고, 인증이 실패하면 exception 을 throw 합니다. 인증의 과정은 다음과 같습니다.

• AuthenticationManager 인터페이스의 authenticate 메서드를 실행하면 AuthenticationManager 의 구현체의 authenticate 메서드를 실행합니다. 보통 ProviderManager 가 사용됩니다.
• ProviderManager 는 List of AuthenticationProvder 에게 인증을 위임합니다.
• AuthenticationManager 인터페이스의 authenticate 의 인자로 UserPasswordAuthenticationToken 을 받는다면 AuthenticationProvder 의 구현체인 DaoAuthenticationProvider 를 사용합니다.
• DaoAuthenticationProvider 는 UserDetailService 를 사용해 UserDetails 객체를 생성하여 UserPasswordAuthenticationToken  과 비교합니다.
• 인증이 성공하면 권한과 사용자 정보가 담긴 Authentication 객체를 return 합니다.

authenticate 를 사용하여 받아온 Authentication 객체는 authenticatie 를 호출한 곳에서 SecurityContextHolder 에 설정하도록 합니다.

Spring Security 에서 예외가 발생하면 ExceptionTranslationFilter 에서 Exception 을 감지하고 처리합니다. 특히 AuthenticationException 과 AccessDeniedException 을 감지하여 각각 AuthenticationEntrypoint 와 AccessDeniedHandler 에서 Exception 이 다뤄집니다.

 

구현 코드

 

CustomUserDetails

public class CustomUserDetails implements OAuth2User, UserDetails {
    private Long id;
    private String email;
    private String password;
    private Collection<? extends GrantedAuthority> authorities;
    private Map<String, Object> attributes;

    public CustomUserDetails(Long id, String email, String password, Collection<? extends GrantedAuthority> authorities) {
        this.id = id;
        this.email = email;
        this.password = password;
        this.authorities = authorities;
    }

    public static CustomUserDetails create(Member member) {
        List<SimpleGrantedAuthority> authorities = Collections
                .singletonList(new SimpleGrantedAuthority(member.getRole().getValue()));

        return new CustomUserDetails(member.getId(),
                member.getEmail(),
                member.getPassword(),
                authorities);
    }

    public static CustomUserDetails create(Member member, Map<String, Object> attributes) {
        CustomUserDetails userDetails = CustomUserDetails.create(member);
        userDetails.setAttributes(attributes);
        return userDetails;
    }

    public Long getId() {
        return id;
    }

    // UserDetail Override
    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return email;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    // OAuth2User Override
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @Override
    public Map<String, Object> getAttributes() {
        return attributes;
    }

    @Override
    public String getName() {
        return String.valueOf(id);
    }

    public void setAttributes(Map<String, Object> attributes) {
        this.attributes = attributes;
    }

}

추후 OAuth2 적용 시 같은 객체를 사용하기 위해서 CustomUserDetails 는 UserDetails 와 OAuth2User 모두 구현했습니다.  getUsername 이 email 을 return 하도록 하여 추후 UserDetailService 의 loadByUsername 의 인자로 email 을 받을 수 있도록 합니다.

 

CustomUserDeatilService

@Service
@RequiredArgsConstructor
public class CustomUserDetailService implements UserDetailsService {

    private final MemberRepository memberRepository;

    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        Member member = memberRepository.findByEmail(email)
                .orElseThrow(() -> new RuntimeException("no member"));
        return CustomUserDetails.create(member);
    }

    public UserDetails loadUserById(Long id) throws UsernameNotFoundException {
        Member member = memberRepository.findOne(id)
                .orElseThrow(RuntimeException::new);
        return CustomUserDetails.create(member);
    }

}

loadUserByUsername 메서드는 email 을 사용해 member 를 찾고, member 를 사용해 CustomUserDetails 객체를 생성합니다. 인증과정에서 쓰이지는 않지만 id 를 사용해 CustomUserDetails 객체를 생성해야하는 경우가 있어 loadUserById 메서드도 추가적으로 구현했습니다.

 

JwtProvider 

@Component
@RequiredArgsConstructor
public class JwtProvider {

    @Value("${auth.token.secret-key}")
    private String SECRET_KEY;
    private final Long ACCESS_TOKEN_EXPIRE_LENGTH = 1000L * 60 * 60;        // 1hour
    private final Long REFRESH_TOKEN_EXPIRE_LENGTH = 1000L * 60 * 60 * 24 * 7;    // 1week
    private final String AUTHORITIES_KEY = "role";

    private final CustomUserDetailService customUserDetailService;

    private String createToken(Authentication authentication, Long tokenExpireLength) {

        Date now = new Date();
        Date expiration = new Date(now.getTime() + tokenExpireLength);

        CustomUserDetails user = (CustomUserDetails) authentication.getPrincipal();
        String userId = user.getName();
        String role = authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(","));

        return Jwts.builder()
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .setSubject(userId)
                .claim(AUTHORITIES_KEY, role)
                .setIssuedAt(now)
                .setExpiration(expiration)
                .compact();

    }

    public String createAccessToken(Authentication authentication) {
        return createToken(authentication, ACCESS_TOKEN_EXPIRE_LENGTH);
    }

    public String createRefreshToken(Authentication authentication) {
        return createToken(authentication, REFRESH_TOKEN_EXPIRE_LENGTH);
    }

    public Long findMemberId(String token) {
        return Long.valueOf(parseClaims(token).getSubject());
    }

    public Authentication getAuthentication(String token) {

        UserDetails userDetails = customUserDetailService.loadUserById(findMemberIdByJwt(token));
        return new UsernamePasswordAuthenticationToken(userDetails,
                "",
                userDetails.getAuthorities());
    }

    public JwtResultType validateToken(String token) {

        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return JwtResultType.VALID_JWT;
        } catch (ExpiredJwtException e) {
            System.out.println("만료된 JWT 토큰입니다.");
            return JwtResultType.EXPIRED_JWT;
        } catch (Exception e) {
            System.out.println("JWT 토큰이 잘못되었습니다");
            return JwtResultType.INVALID_JWT;
        }

    }

    private Claims parseClaims(String accessToken) {

        try {
            return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(accessToken).getBody();
        } catch (ExpiredJwtException e) {
            return e.getClaims();
        }

    }

}

JWT 를 생성, 검증하는 클래스입니다. 추가적으로 토큰을 입력받아 MemberId 를 return 하는 findMemberId 메서드와 Authentication 을 return 하는 getAuthentication 메서드가 있습니다.

 

JwtResultType

public enum JwtResultType {
    VALID_JWT, EXPIRED_JWT, INVALID_JWT
}

JWT 를 검증한 결과를 정의한 enum 입니다. ExpiredJwtException 은 다른 Exception 들과 다른 로직을 처리해야하기 때문에, enum 을 정의하여 JwtProvider 클래스의 validateToken 메서드의 return 값으로 사용했습니다. 

 

JwtFilter

@RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {

    private final String TOKEN_PREFIX = "Bearer ";
    private final JwtProvider jwtProvider;
    private final List<String> EXCLUDE_URL_PATTERN = List.of(
            "/api/login",
            "/api/signup",
            "/api/admin/signup",
            "/oauth2/**"
    );

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        String pathName = request.getServletPath();
        return EXCLUDE_URL_PATTERN.stream().anyMatch(url -> {
            if (url.endsWith("/**")) {
                return pathName.startsWith(url.substring(0, url.length() - 3));
            } else {
                return url.equalsIgnoreCase(pathName);
            }
        });
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {

        String token = getJwtFromRequest(request);

        if (StringUtils.hasText(token)) {

            JwtResultType jwtResultType = jwtProvider.validateToken(token);
            if (jwtResultType == JwtResultType.VALID_JWT) {
                Authentication authentication = jwtProvider.getAuthentication(token);
                SecurityContextHolder.getContext().setAuthentication(authentication);

                filterChain.doFilter(request, response);
            } else if (jwtResultType == JwtResultType.EXPIRED_JWT) {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType(APPLICATION_JSON_VALUE);
                response.setCharacterEncoding("utf-8");

                JSONObject json = new JSONObject();
                json.put("code", 401);
                json.put("message", "Access Token 이 만료되엇습니다.");
                response.getWriter().print(json);
            } else {
                response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
                response.setContentType(APPLICATION_JSON_VALUE);
                response.setCharacterEncoding("utf-8");

                JSONObject json = new JSONObject();
                json.put("code", 400);
                json.put("message", "잘못된 JWT 입니다.");
                response.getWriter().print(json);
            }
        } else {
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            response.setContentType(APPLICATION_JSON_VALUE);
            response.setCharacterEncoding("utf-8");

            JSONObject json = new JSONObject();
            json.put("code", 400);
            json.put("message", "JWT 가 존재하지 않습니다.");
            response.getWriter().print(json);
        }

    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(TOKEN_PREFIX)) {
            return bearerToken.substring(TOKEN_PREFIX.length());
        }
        return null;
    }

}

request 의 header 에서 token 을 가져와 검증하는 filter 입니다. shouldNotFilter 메서드는 request 의 path name 이 EXCLUDE_URL_PATTERN 과 매칭된다면 true 를 return 하여 filtering 를 하지 않도록 합니다.

doFilterInternal 메서드는 JWT 를 가져와 검증하여, 유효한 JWT 라면 Authentication 을 생성해 SecurityContext 에 저장합니다. 검증되지 않는다면 error 를 response 합니다.

 

CustomAuthenticationEntryPoint

@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.setContentType(APPLICATION_JSON_VALUE);
        response.setCharacterEncoding("utf-8");

        JSONObject json = new JSONObject();
        json.put("code", 401);
        json.put("message", authException.getLocalizedMessage());

        response.getWriter().print(json);
    }

}

인증이 실패한 경우 401 status 와 error message 를 response 하도록 설정했습니다.

 

CustomDeniedHandler

@Component
public class CustomDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        response.setContentType(APPLICATION_JSON_VALUE);
        response.setCharacterEncoding("utf-8");

        JSONObject json = new JSONObject();
        json.put("code", 403);
        json.put("message", accessDeniedException.getLocalizedMessage());

        response.getWriter().print(json);
    }
}

권한이 없는 경우 403 status 와 error message 를 response 하도록 설정했습니다.

 

 

SecurityConfig

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final JwtProvider jwtProvider;
    private final CustomAuthenticationEntryPoint customAuthenticationEntryPoint;
    private final CustomDeniedHandler customDeniedHandler;

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public RoleHierarchy roleHierarchy() {
        RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();

        roleHierarchy.setHierarchy("ROLE_ADMIN > ROLE_MANAGER > ROLE_MEMBER > ROLE_GUEST");
        return roleHierarchy;
    }

    @Bean
    public AccessDecisionVoter<? extends Object> roleVoter() {
        RoleHierarchyVoter roleHierarchyVoter = new RoleHierarchyVoter(roleHierarchy());
        return roleHierarchyVoter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .formLogin().disable()
                .httpBasic().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .exceptionHandling()
                .authenticationEntryPoint(customAuthenticationEntryPoint)
                .accessDeniedHandler(customDeniedHandler)
                .and()
                .authorizeRequests()
                .antMatchers("/api/login", "/api/signup", "/api/admin/signup", "/oauth2/**")
                .permitAll()
                .antMatchers("/api/refresh")
                .authenticated()
                .antMatchers(HttpMethod.GET, "/api/my").hasRole("MEMBER")
                .antMatchers("/api/admin/my").hasRole("ADMIN")
                .anyRequest()
                .authenticated()
                .and()
                .addFilterBefore(new JwtFilter(jwtProvider), UsernamePasswordAuthenticationFilter.class);

    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

AuthenticationManager 의 Bean 을 반드시 생성해 주어야 합니다. Bean 생성이 없으면 exception 이 발생합니다.

roleHierarchy 는 권한에 계층을 설정해 주고, roleVoter 는 roleHierachy 를 사용해 해당 계층을 등록해 줍니다. 우리는 ROLE_ADMIN 은 ROLE_MEMBER 의 모든 권한을 가지기 원합니다. 하지만 이러한 계층 설정이 없다면, ROLE_ADMIN 은 ROLE_ADMIN 의 권한만 가지게 됩니다. 따라서 권한 계층을 등록하여 상위 권한은 하위 권한을 가지도록, 즉 ROLE_ADMIN 은 ROLE_MEMBER 의 권한을 모두 가지도록 설정해줍니다. 

restful api 를 개발중이므로 csrf(), formLogin(), httpBasic() 을 모두 disable() 처리하고 session 을 stateless 하도록 설정합니다. 앞서 선언한 CustomAuthenticationEntryPoint 와 CustmDeniedHandler 를 등록해줍니다. antMatchers 를 통해 특정 Url Pattern 마다 다른 속성을 부여합니다. permitAll() 은 인증이 없이 모두 통과하고, authenticated() 는 인증 필요, hasRole() 은 인자로 받은 권한을 가지는 경우만 통과시킵니다. 마지막으로  앞서 정의한 JwtFilter 를UsernamePasswordAuthenticationFilter 앞에 등록합니다.

 

AuthController

@RestController
@RequiredArgsConstructor
public class AuthController {

    private final AuthService authService;
    private final RefreshTokenService refreshTokenService;

    private final PasswordEncoder passwordEncoder;
    private final AuthenticationManager authenticationManager;
    private final JwtProvider jwtProvider;

    @PostMapping("/api/login")
    public ResponseEntity<LoginResponseDto> login(@RequestBody LoginRequestDto loginRequestDto, HttpServletResponse response) {
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequestDto.getEmail(),
                        loginRequestDto.getPassword())
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);

        String accessToken = jwtProvider.createAccessToken(authentication);
        String refreshToken = jwtProvider.createRefreshToken(authentication);
        Member member = authService.getMemberByEmail(authentication.getName());

        refreshTokenService.update(member, refreshToken);
        CookieUtil.addCookie(response, "REFRESH_TOKEN", refreshToken, 60 * 60 * 24 * 7);

        return ResponseEntity.ok(new LoginResponseDto(member.getId(), accessToken));
    }

    @PostMapping("/api/signup")
    public ResponseEntity<Void> signup(@RequestBody SignupRequestDto signupRequestDto) {
        if (!authService.memberValidCheck(signupRequestDto.getEmail())) {
            throw new RuntimeException("멤버 있음");
        }
        Member member = Member.builder()
                .name(signupRequestDto.getName())
                .sex(signupRequestDto.getSex())
                .birthday(signupRequestDto.getBirthday())
                .email(signupRequestDto.getEmail())
                .password(passwordEncoder.encode(signupRequestDto.getPassword()))
                .role(MemberRole.MEMBER)
                .authProvider(AuthProvider.EMAIL)
                .build();

        Long memberId = authService.save(member);

        return ResponseEntity.created(URI.create("/api/members/" + memberId)).build();
    }

    @GetMapping("/api/refresh")
    public ResponseEntity<TokenResponseDto> reissue(HttpServletRequest request) {

        String authorizationHeader = request.getHeader("Authorization");
        String refreshToken = authorizationHeader.substring("Bearer ".length());

        Authentication authentication = jwtProvider.getAuthentication(refreshToken);
        Member member = authService.getMemberByEmail(authentication.getName());

        RefreshToken refreshTokenObj = refreshTokenService.getRefreshTokenByMember(member);
        if (!refreshTokenObj.getRefreshToken().equals(refreshToken)) {
            throw new RuntimeException("refresh token 이 다름");
        }

        String newAccessToken = jwtProvider.createAccessToken(authentication);
        TokenResponseDto tokenResponseDto = new TokenResponseDto();
        tokenResponseDto.setAccessToken(newAccessToken);

        return ResponseEntity.ok(tokenResponseDto);
    }

    @GetMapping("/api/my")
    public ResponseEntity<String> getMy() {
        return ResponseEntity.ok("mymy");
    }

}

 

GET /api/refresh 는 SecurityConfig 에서 authenticate() 처리되어, 토큰을 사용해 인증되어야 사용할 수 있습니다. 

GET /api/my 는 SecurityConfig 에서 hasRole("MEMBER") 처리되어, ROLE_MEMBER 의 권한을 가진 토큰을 사용해 인증을 해야 사용할 수 있습니다. 추가로 ""ROLE_ADMIN" 도 ROLE_MEMBER" 의 권한을 가지므로 해당 api 를 사용할 수 있습니다.

 

AdminController

@Controller
@RequiredArgsConstructor
public class AdminController {

    private final AuthService authService;
    private final PasswordEncoder passwordEncoder;

    @GetMapping("/api/admin/my")
    public ResponseEntity<String> getAdminMy() {
        return ResponseEntity.ok("admin mymy");
    }

    @PostMapping("/api/admin/signup")
    public ResponseEntity<Void> signup(@RequestBody SignupRequestDto signupRequestDto) {
        if (!authService.memberValidCheck(signupRequestDto.getEmail())) {
            throw new RuntimeException("멤버 있음");
        }
        Member member = Member.builder()
                .name(signupRequestDto.getName())
                .sex(signupRequestDto.getSex())
                .birthday(signupRequestDto.getBirthday())
                .email(signupRequestDto.getEmail())
                .password(passwordEncoder.encode(signupRequestDto.getPassword()))
                .role(MemberRole.ADMIN)
                .authProvider(AuthProvider.EMAIL)
                .build();

        Long memberId = authService.save(member);

        return ResponseEntity.created(URI.create("/api/admin/members/" + memberId)).build();
    }

}

GET /api/admin/my 는 SecurityConfig 에서 hasRole('ADMIN') 처리되어, ROLE_ADMIN 권한을 가진 토큰을 사용해 인증해야 사용할 수 있습니다. ROLE_MEMBER 권한을 가진 토큰을 사용하여 인증하면 403 error 를 response 하게 됩니다. 

 

이렇게 Spring Security 와 JWT 를 사용한 간단한 프로젝트를 마무리 하였습니다. 프로젝트를 진행하며 몇 가지 고칠 부분이 있습니다.

먼저, Exception 관련 처리입니다. 원래 RuntimeException 들이 아닌 상황에 맞는 Exception 을 생성하고, 그 Exception 들을 @ExceptionHandler 등을 사용해 처리했어야 했는데 Spring Security 와 JWT 에 초점을 맞추다 보니 간단하게 구현했습니다.

다음 JwfFilter 입니다. 현재 프로젝트에서는 인증이 필요할 때는 JwtFilter 에서 error 를 response 하거나, 인증을 거쳐Authentication 을 생성해 SecurityContext 에 저장합니다. 따라서 AuthenticationFilter 인 UsernamePasswordAuthenticationFilter 는 사실상 동작하지 않습니다. 그렇다면 JwtFilter 에서는 예외만 처리하고, UsernamePasswordAuthenticationFilter 를 상속한 Filter 를 만들어 그곳에서 인증절차를 진행하는 것이 더 좋은 방법일지도 모른다는 생각이 듭니다. 

 

참조
https://docs.spring.io/spring-security/reference/5.6/index.html
https://hungseong.tistory.com/67
https://onejunu.tistory.com/137