🚀 Spring Security 의존성 탈출기

❓개요

Spring Security 를 사용하여 JWT 토큰 방식의 인증/인가를 구현하게되면 사용하게 되는 UserDetatilsService, UserDetails 가 있습니다. 이 둘을 사용해 JWT 토큰 방식으로 구현하게 되면 Spring Security 가 무슨일을 하고 어떠한 문제가 발생하는지 알아보도록 하겠습니다

📎 각자의 책임

UserDetails

package org.springframework.security.core.userdetails;

import java.io.Serializable;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public interface UserDetails extends Serializable {
    Collection<? extends GrantedAuthority> getAuthorities(); // 권한 

    String getPassword(); // 비밀번호 

    String getUsername(); // 식별 정보 

    default boolean isAccountNonExpired() { // 계정 만료 여부 
        return true;
    }

    default boolean isAccountNonLocked() { // 계정 잠금 여부 
        return true;
    }

    default boolean isCredentialsNonExpired() { // 비밀번호 만료 여부 
        return true;
    }

    default boolean isEnabled() { // 계정 활성화 여부 
        return true;
    }
}

• UserDeatils 의 역할은 Spring Security 에서 사용자의 정보를 나타내는데에 사용됩니다.
• 사용자의 인증 상태와 권한을 종합적으로 확인하고 관리할 수 있도록 하는 역할을 가지고 있습니다.

UserDeatilsService

package org.springframework.security.core.userdetails;

public interface UserDetailsService {
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

• Spring Security 에서 사용자 정보를 로드하는 인터페이스입니다.
• 실제 사용자 정보가 저장된 곳(DB, 외부 시스템 등)에서 사용자 정보를 가져와 UserDetails 객체로 변환하여 반환하는 역할을 가지고 있습니다.

필터를 제외하고 위에 둘을 구현하게 되면 JWT 토큰 인증/인가 방식을 사용할 수 있게됩니다. Spring Security 가 많은 책임을 가지고 인증/인가를 대신 수행하게됩니다. 하지만 이 둘을 이용하게 되면 생기는 문제점이 있습니다. 이 부분을 다루기 전에 뒤에서 설명하게 될 AuthenticationProvider 책임에 대해 다루고 넘어가도록 하겠습니다.

AuthencationProvider

package org.springframework.security.authentication;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;

public interface AuthenticationProvider {
    Authentication authenticate(Authentication authentication) throws AuthenticationException;

    boolean supports(Class<?> authentication);
}

• authenticate()
  • 실제 인증을 처리하는 메서드입니다.
  • UserDetailsService를 이용하여 인증 로직에 대한 비즈니스 로직을 구현할 수 있습니다.
• supports()
  • 해당 Provider가 특정 Authentication 타입을 지원하는지 여부를 확인하게 됩니다.
  • 비즈니스로직에 따라 인증 로직을 달리하고 싶을때 supports 를 통해 해당 AuthenticationProvider 가 인증을 수행해야하는지 여부를 판단하게 됩니다.

Spring Security 에서의 각자 책임을 살펴보았습니다. Spring Security를 이용하게 되면 인증/인가를 수행하기 편리하고 객체지향적으로 구조를 설계할 수 있게됩니다. 반대로 단점도 존재합니다. Spring Security 가 이미 많은것을 해주고 있기때문에 디버깅이 힘들다는 점이 생기게 됩니다. 또한 여러가지 문제점이 생기게 되는데 이 부분의 대해 한번 알아보도록 하겠습니다.

👕 맞지 않는 옷

UserDeatilsService를 사용허게 되면 생기는 문제점입니다. JWT 토큰방식으로 인증을 수행할 때 식별자 정보를 ID 또는 Email 을 사용을 할 경우를 이야기해보도록 하겠습니다.

첫번째로는 JWT 토큰 인증방식을 선택하여 구현하는 경우 UserDetailsService 는 로그인 시 사용하게 됩니다. 하지만 로그인 할때 ID 또는 Email 을 사용하게 되면 Naming Miss Match 가 발생하게 됩니다. UserDeatilsService 는 username 으로 사용자를 찾는 것에 관심이 있지만 JWT 인증/인가 방식은 Claim 정보에 좀 더 관심이 있습니다.

두번째로는 JWT 토큰 인증 방식을 이용하여 구현할 경우 UserDetailsService 는 로그인 시에만 이용하게 됩니다. UserDetailsService 는 Spring Security 의 전반적인 인증 과정을 위해 설계되었지만 로그인 시에만 이용하는것으로 제한하게 된다면 설계 의도에 어긋나게 됩니다.

🧳 불필요한 수화물

UserDetails를 사용하게 되면 구현해야 하는 메서드들이 여러개 존재하게 됩니다. 이 메서드들의 문제점을 다뤄보도록 하겠습니다.

첫번째로는 getPassword() 메서드입니다. JWT 토큰 인증방식에는 사용하지 않는 getPassword() 입니다. 해당 메서드를 구현을 강제하도록 하고 있으니 구현하게 되면 return 값에는 null 을 반환하도록 구현하게 되므로 의미없는 구현을 하게됩니다.

두번째 또한 의미없는 구현이 될 수도 있는 메서드입니다. 해당 메서드들은 JWT 불필요할 수 있습니다.

JWT는 토큰 자체의 만료시간과 검증을 사용하는데 UserDetails는 계정 상태 체크 메서드들을 강제로 구현해야는 문제점을 안고 있습니다.

추가로 SecurityContext 에 저장되는 Authentication 객체와 UserDetails정보이 생명주기 불일치하는 문제가 발생할 수 발생할 수 있습니다. 로그인 후에 발생하는 사용자 상태 변화에 대해 UserDetails의 정보 갱신이 어려움이 생길 수 있습니다. UserDeatils, UserDetailsService 에 대한 여러 문제점을 살펴보았습니다. 이러한 문제점을 해결해보도록 하겠습니다.

📌 Spring Security 내부로 들어가기

userDetails 를 이용하여 구현하게 되면 AuthenticationProvider 는 Authentication 이라는 인증 객체를 만들어 SecurityContextHolder 에 저장하게 됩니다. 그렇다면 UserDetails 을 사용하지 않고 Authentication 이라는 인터페이스를 직접 만들어 SecurityContextHolder 에 저장하게 되면 Spring Security의 장점을 가져가면서 객체지향적으로 코드를 구현할 수 있게 됩니다. 흐름도를 먼저 설명하기 전에 각자 책임을 갖고 구현해야하는 필터에 대해서 설명하겠습니다.

AbstractAuthenticationProcessingFilter

package org.springframework.security.web.authentication;

public abstract class AbstractAuthenticationProcessingFilter extends GenericFilterBean implements ApplicationEventPublisherAware, MessageSourceAware {

    public abstract Authentication attemptAuthentication
    (
		    HttpServletRequest request, 
		    HttpServletResponse response
    ) throws AuthenticationException, IOException, ServletException;
}

JWT 토큰 인증방식을 이용해 인증 필터를 구현할때 대표적인 필터가 UsernamePasswordAuthenticationFilter 가 있습니다. UsernamePasswordAuthenticationFilter 에 상위 구현체가 AbstractAuthenticationProcessingFilter 입니다. 해당 필터를 상속받아 조금 더 Custom 하게 인증 필터를 구현할 수 있습니다. 하지만 GenericFilterBean 을 상속받기 때문에 한번 요청에 중복되는 인증을 수행할 수 있는 문제점이 발생하는데 SecurityContext 를 확인하여 이미 인증된 사용자인지 체크하는 방법이 존재합니만 해당 주제에서 벗어난 주제이기에 다루지 않도록 하겠습니다.

인가 필터는 OncePerRequestFilter 를 이용하여 구현하면 됩니다. 해당 필터를 이용하여 인가 흐름은

1. URI를 확인하여 인가가 필요한지 여부를 확인
2. JWT 토큰을 헤더 또는 쿠키에서 정보 가져오기
3. JWT 토큰 유효성 검사 (JWT Provider 에게 책임 위임)
4. 인증이 정상적으로 수행되었다면 SecurityContextHolder 에 저장

해당 흐름대로 진행한다면 관심사와 책임을 잘 가지고 있는 필터가 될 것입니다.

코드적인 부부은 마지막 부분에서 다루도록 하고 흐름도에 대해서 중점적으로 설명하겠습니다.

🎨 그림으로 이해해보기

로그인 인증 흐름

로그인 인증 흐름은 다음과 같습니다.

• ID 와 Password를 입력받았을때 AbstractAuthenticationProcessingFilter 를 구현한 LoginAutehnticationFilter 로 도착하게 됩니다.
• LoginAuthenticationFilter 는 Json 을 파싱하여 인증되지 않은 Authentication 을 만들어 AuthenticationProvider 에게 인증을 위임합니다.
• AuthenticationProvider 를 구현한 LoginAuthenticationProvider 는 비즈니스 로직에 따라 인증을 실질 적으로 수행하게 됩니다. 여기서는 DB를 통해 사용자 정보를 확인하여 인증된 Authentication 을 발급합니다.
• LoginAuthenticationProvider 로 부터 인증된 Authentication 이 LoginAuthenticationFilter 에 도착하면 successfulAuthentication 에서 토큰을 헤더 또는 쿠키에 담아서 클라이언트에게 응답하면됩니다.
• 만약 인증에 실패하였다면 unsuccessfulAuthentication 를 통해 인증 실패에 대한 정보를 클라이언트에게 응답하면 됩니다.

JWT 인가 흐름

JWT 토큰 인증 흐름은 다음과 같습니다.

• 클라이언트로 부터 JWT 토큰 정보를 요청받게 되면 OncePerRequestFilter 를 구현한 JwtAuthorizationFilter 에 도착하게 됩니다.
• JwtAuthorizationFilter 는 JwtToken을 추출을 JwtProvider 에게 위임하여 JwtToken 정보를 확인합니다.
• JwtToken 정보를 확인하였다면 Authentication 인증 객체를 생성합니다.
• 인증 된 Authentication 객체를 SecurityContext 에 저장하여 클라이언트가 서비스를 이용할 수 있도록 합니다.

🧑‍💻 전체적인 코드

Principal

@Getter
public class AuthUser {

    private final Long id;
    private final String email;
    private final Collection<? extends GrantedAuthority> authorities;

    public AuthUser(Long id, String email, Role role) {
        this.id = id;
        this.email = email;
        this.authorities = List.of(new SimpleGrantedAuthority("ROLE_" + role));
    }

    public static AuthUser from(User user) {
        return new AuthUser(user.getId(), user.getEmail(), user.getRole());
    }
}

• User 정보를 대체할 객체입니다.

Authentication

package com.my.relink.config.security;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;

import java.util.Collection;
import java.util.Collections;

public class LoginAuthentication implements Authentication {
    private final String email;
    private final String password;
    private boolean authenticated;
    private AuthUser principal;

    public LoginAuthentication(String email, String password) { // 인증 전 
        this.email = email;
        this.password = password;
        this.authenticated = false;
    }

    public LoginAuthentication(AuthUser authUser) { // 인증 후 
        this.email = authUser.getEmail();
        this.password = null;
        this.authenticated = true;
        this.principal = authUser;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return principal != null ? principal.getAuthorities() : Collections.emptyList();
    }

    @Override
    public Object getCredentials() {
        return password;
    }

    @Override
    public Object getDetails() {
        return principal;
    }

    @Override
    public Object getPrincipal() {
        return authenticated ? principal : email;
    }

    @Override
    public boolean isAuthenticated() {
        return authenticated;
    }

    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
        this.authenticated = isAuthenticated;
    }

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

• Authentication 상태는 인증 전/인증 후 두 가지 상태를 가지고 있습니다.

AuthenticationProvider

package com.my.relink.config.security;

import com.my.relink.domain.user.User;
import com.my.relink.domain.user.repository.UserRepository;
import com.my.relink.ex.ErrorCode;
import com.my.relink.ex.SecurityFilterChainException;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

@Component
@RequiredArgsConstructor
public class LoginAuthenticationProvider implements AuthenticationProvider {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        LoginAuthentication loginAuthentication = (LoginAuthentication) authentication;
        String email = loginAuthentication.getName();
        String password = (String) loginAuthentication.getCredentials();

        User user = userRepository.findByEmailActiveUser(email)
                .orElseThrow(() -> new SecurityFilterChainException(ErrorCode.USER_NOT_FOUND));

        if (!passwordEncoder.matches(password, user.getPassword())) {
            throw new SecurityFilterChainException(ErrorCode.MISS_MATCHER_PASSWORD);
        }

        return new LoginAuthentication(AuthUser.from(user));
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return LoginAuthentication.class.isAssignableFrom(authentication);
    }
}

• DB 에서 사용자 정보를 가져와 인증을 수행하게됩니다.
• AuthenticationProvider 는 인증이 어떻게 수행되는지에 대한 자세한 이야기를 알고 있습니다.

AbstractAuthenticationProcessingFilter

package com.my.relink.config.security;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.my.relink.config.security.dto.req.LoginRepDto;
import com.my.relink.config.security.dto.resp.LoginRespDto;
import com.my.relink.config.security.jwt.JwtProvider;
import com.my.relink.domain.user.User;
import com.my.relink.domain.user.repository.UserRepository;
import com.my.relink.ex.ErrorCode;
import com.my.relink.ex.SecurityFilterChainException;
import com.my.relink.util.api.ApiResult;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class LoginAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

    private final ObjectMapper objectMapper;
    private final JwtProvider jwtProvider;
    private final UserRepository userRepository;

    public LoginAuthenticationFilter(AuthenticationManager authenticationManager, ObjectMapper objectMapper, JwtProvider jwtProvider, UserRepository userRepository) {
        super(new AntPathRequestMatcher("/auth/login", HttpMethod.POST.name()));
        this.setAuthenticationManager(authenticationManager);
        this.objectMapper = objectMapper;
        this.jwtProvider = jwtProvider;
        this.userRepository = userRepository;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            LoginRepDto loginRequest = objectMapper.readValue(request.getInputStream(), LoginRepDto.class);

            LoginAuthentication loginAuthentication = new LoginAuthentication(
                    loginRequest.getEmail(),
                    loginRequest.getPassword()
            );
            return this.getAuthenticationManager().authenticate(loginAuthentication);
        } catch (IOException ex) {
            throw new SecurityFilterChainException(ErrorCode.JSON_PARSE_ERROR, ex);
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        String token = jwtProvider.generateToken(authResult);
        User user = userRepository.findByEmail(authResult.getName())
                .orElseThrow(() -> new SecurityFilterChainException(ErrorCode.USER_NOT_FOUND));

        response.addHeader("Authorization", token);
        response.setStatus(HttpStatus.OK.value());
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        response.getWriter().write(objectMapper.writeValueAsString(ApiResult.success(new LoginRespDto(user))));
    }

    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        response.getWriter().write(objectMapper.writeValueAsString(ApiResult.error(ErrorCode.INVALID_CREDENTIALS)));
    }
}

• 해당 필터에 책임은 인증 전 Authentication을 만들어 인증을 위임하고 인증이 성공 또는 실패에 대한 책임을 가지고 있습니다.

AuthorizationFilter

package com.my.relink.config.security;

import com.my.relink.config.security.jwt.JwtProvider;
import com.my.relink.ex.ErrorCode;
import com.my.relink.ex.SecurityFilterChainException;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;
import java.util.List;

@Component
@RequiredArgsConstructor
public class JwtAuthorizationFilter extends OncePerRequestFilter {

    private final JwtProvider jwtProvider;

    private final List<String> publicPaths;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

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

        if (isPublicPath(request.getRequestURI())) {
            filterChain.doFilter(request, response);
            return;
        }

        String tokenValue = request.getHeader(JwtProvider.AUTHENTICATION_HEADER_PREFIX);
        if (tokenValue == null) {
            throw new SecurityFilterChainException(ErrorCode.TOKEN_NOT_FOUND);
        }
        String token = tokenValue.replace(JwtProvider.TOKEN_PREFIX, "");
        jwtProvider.validateToken(token);

        AuthUser authUser = jwtProvider.getAuthUserForToken(token);

        LoginAuthentication loginAuthentication = new LoginAuthentication(authUser);
        SecurityContextHolder.getContext().setAuthentication(loginAuthentication);
        filterChain.doFilter(request, response);
    }

    private boolean isPublicPath(String uri) {
        return publicPaths.stream()
                .anyMatch(path -> antPathMatcher.match(path, uri));
    }
}

• 해당 필터는 인가를 수행하는 필터이기에 인가 필터에서 수행하는 URI 인지를 확인한 후 토큰 유효성을 검증하여 SecurityContextHolder 에 저장하는 책임을 가지고 있습니다.

📖 톺아보기

• 불필요한 메서드, 네이밍 불일치, 생명주기 불일치 등 여러 문제점을 확인해보았습니다.

• 인증 객체를 직접 구현함으로써 여러 단점들을 해소했습니다.
• Spring Security 에 구조적인 장점을 살릴 수 있었으며 객체지향적으로 설계할 수 있었습니다.
• Spring Security 는 매우 강력한 프레임워크이며 개발자가 인증/인가 구현을 편하게 할 수 있게 하는 반면 모든것을 Spring Security 에 의존하게 되면 디버깅과 여러 아키텍쳐적인 문제점이 발생할 수 있습니다.
• 편리한 프레임워크를 이용하기에 앞서 프레임워크에 내부적인 동작방식에대해 잘 이해하고 사용하게 된다면 여러 문제점을 해소할 수 있습니다.