[Security] OAuth2.0 로그인 후처리 - 권한 부여, 데이터베이스 저장

이 전 포스팅에서 OAuth2.0을 통한 구글 소셜 로그인을 적용해보았습니다.

하지만 단순히 로그인만 성공 했을 뿐 아직 남은 문제들이 있습니다.

 

1. 아직 소셜 로그인으로 로그인한 사용자에 대한 정보가 데이터베이스에 없습니다.

▶︎ 데이터베이스에 소셜 로그인한 사용자의 정보를 커스텀해서 저장 필요

 

2. 소셜 로그인한 사용자에 대한 접근 권한이 주어지지 않았습니다.

▶︎ 소셜 로그인 사용자에 대해 접근 권한 설정 (이 또한 데이터베이스에 저장 시 Role 설정으로써 해결)

 

이번 포스팅에서는 주어진 위의 문제들을 Spring Security 내부에서 처리해보도록 합시다!

 

일반 로그인 로직을 다시 한 번 정리. 

인증 관련 아키텍쳐 Flow

1. Request ➡️ AuthenticationFilter

: 클라이언트가 AuthenticationFilter에 등록된 요청을 할 경우 Filter가 이를 낚아채서 처리합니다.

 

2. AuthenticationFilter ➡️ UsernamePasswordAuthenticationToken

: Filter에서 UsernamePasswordAuthenticationToken에게 인증 전 객체를 전달하여 인증용 객체를 하나 만들어 필터에게 리턴합니다.

 

3. AuthenticationFilter ➡️ AuthenticationManager

: 리턴 받은 인증용 객체를 AuthenticationManager에게 전달합니다.

 

4. AuthenticationManager ➡️ AuthenticationProvider

: AuthenticationManager에 등록된 AuthenticationProvider를 찾아서 인증용 객체를 전달합니다.

 

5. AuthenticationProvider ➡️ UserDetailsService

: Provider에서 UserDetailsService에게 DB에 접근하여 인증 절차를 ID와 PASSWORD로 검증하도록 지시합니다.

 

6. UserDetailsService ➡️ UserDetails ➡️ UserDetailsService 

: UserDetailsService는 실제 DB에 접근하여 해당 ID와 PW가 일치하는 회원이 있는지 검사한 이후, 있으면 해당 데이터에 대한 정보를 UserDetails에 담아 리턴합니다.

 

7. UserDetailsService ➡️ AuthenticationProvider

: Provider에게 UserDetails를 전달합니다.

 

8. AuthenticationProvider ➡️ AuthenticationManager

: Authentication 객체 안에 UserDetails를 담아 Authentication 객체를 AuthenticationManager에게 전달합니다.

 

9,10. AuthenticationManager ➡️ AuthenticationFilter ➡️ SecurityContext 

: 리턴받은 Authentication 객체를 SecurityContextHolder에 전달합니다.

 

이 과정을 토대로 Authentication객체가 SecuritContext에 저장되어 어플리케이션 전반에 걸쳐 전역적인 참조가 가능합니다!

 

이 전에 로그인을 구현할 때는 Security 설정파일에 등록한 필터에서 .loginProcessingUrl("/login")으로 처리해서 /login 주소가 호출이 되면 시큐리티가 낚아채서 2~5 과정을 처리하도록 구현했습니다.

UserDetailsService는 인터페이스를 직접 구현하여 사용했었죠.

 

아래와 같이 UserDetailsService의 loadUserByUsername(String username)에서 바로 DB에 접근하여 일치하는 회원 조회를 통해 UserDetails의 상속 클래스인 PrincipalDetails에 user 정보를 담아 리턴했었습니다.

 

+ Password는 일치여부를 따로 구현하지 않아도 DaoAuthenticationProvider에서 알아서 처리해줍니다.

//  시큐리티 session(내부 Authentication(내부 UserDetails))
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    log.info("username = {}",username);
    User user = userRepository.findByUsername(username);
    if (user != null) {
        return new PrincipalDetails(user);
    }
    return null;
}

 

Manager와 Provider를 직접 만들어 로그인 처리를 구현한 코드는 아래 자료를 참고

Spring Security #3 아키텍처 이해하기, 인증 및 인가 원리

 

Security Context에 Authenticaiton 객체가 담김을 강조하기 위해 일반 로그인 로직을 다시 한 번 정리해보았습니다.

 

일반 로그인과 마찬가지로 OAuth 로그인 또한 Authentication을 Security Context에 담는 과정이 필요합니다!

리소스 접근에 필요한 세션에 SecurityContext가 담겨있고, SecurityContext 안의 Authentication이 담겨있기 때문에, OAuth 소셜 로그인 또한 Authentication 객체가 필요합니다.

 

Tip : 사용자가 인증처리가 완료된 후 다시 사이트를 접속했을 때 세션에 저장된 SecurityContext를 꺼내어 와서 SecurityContextHolder에 저장하게 되고 이는 전역으로 SecurityContext 를 참조할 수 있게 하는 원리가 됩니다.

Authentication 객체

Spring Security는 사실 Authentication 객체 안에는 사실 UserDetails 뿐만 아니라, 소셜 로그인 유저를 위한 OAuth2User 객체 또한 담을 수 있도록 지원합니다.

 

이 전에 일반 로그인 로직에서 UserDetails 구현체인 PrincipalDetails를 만들었었습니다.

 

참고

// Security Session => Authentication => UserDetails(PrincipalDetails)
@Data
public class PrincipalDetails implements UserDetails {
    private User user;

    // 해당 User의 권한을 리턴하는 곳
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> collection = new ArrayList<>();
        collection.add(
                new GrantedAuthority(){
            @Override
            public String getAuthority() {
                return user.getRole();
            }
        });
        return collection;
    }

 

하지만 상속 구조를 잘 이용한다면 일반 로그인과 소셜 로그인을 따로 나누지 않고 PrincipalDetails로 퉁쳐서 이렇게 한 번에 묶을 수 있습니다!

// Security Session => Authentication => UserDetails(PrincipalDetails(user)) or OAuth2User(PrincipalDetails(user,attributes))
@Data
public class PrincipalDetails implements UserDetails, OAuth2User {
    private User user;
    private Map<String, Object> attributes;

    // 일반 로그인
    public PrincipalDetails(User user) {
        this.user = user;
    }

    // Oauth 로그인
    public PrincipalDetails(User user, Map<String, Object> attributes) {
        this.user = user;
        this.attributes = attributes;
    }
    
    ...

• 일반 로그인 유저의 경우, UserDetails를 implements하게 되면 반드시 권한을 리턴하는 getAuthorities()를 포함한 여러 메소드를 오버라이딩하여 구현해주어야 합니다.
• 소셜 로그인 유저의 경우, OAuth2User를 implements하게 되면 반드시 attributes와 name을 리턴하는 두 개의 메소드를 오버라이딩하여 구현해주어야 합니다.

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

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

• 위 처럼 소셜 로그인 유저와 일반 로그인 유저를 생성자로 나누어 PrincipalDetails로 한 번에 묶어서 처리하였습니다.

 

OAuth2User의 UserDetailsService 계층 개발(권한 부여 및 데이터베이스 저장)

일반 로그인에서는 UserDetailsService의 loadByUsernamepassword() 메소드에서 실제 DB에 접근하여 회원을 조회하고 UserDetails를 리턴했습니다.

 

소셜 로그인 또한 로직은 같습니다만, 명확한 차이가 하나 있습니다.

• 일반 로그인 / UserDetailsService : loadUserByUsername()에서 회원 데이터를 기반으로 DB에서 데이터를 검색 PrincipalDetails에 정보를 담아 리턴
• 소셜 로그인 / DefaultOAuth2UserService : userRequest 기반 데이터 검색
  • 최초 로그인 경우 : loadUser(OAuthRequest userRequest)에서 소셜 로그인 데이터 정보인 userRequest를 기반으로 DB에 데이터 삽입 및 PrincipalDetails에 정보를 담아 리턴 
  • 최초 로그인이 아닌 경우 : DB에 데이터를 새로 저장하지 않고 PrincipalDetails에 정보를 담아 리턴

 

아래는 구현 코드입니다.

@Service
@RequiredArgsConstructor
@Slf4j
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    private final UserRepository userRepository;
    private final BCryptPasswordEncoder bCryptPasswordEncoder;

    // 구글로 부터 받은 userRequest에 대한 후처리 함수
    // 함수 종료시 @AuthenticationPrincipal 어노테이션이 만들어짐.
    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        log.info("userRequest.clientRegistration : {}",userRequest.getClientRegistration());
        log.info("userRequest.access_Token : {}",userRequest.getAccessToken());
        log.info("userRequest.access_Token.Token_value  : {}",userRequest.getAccessToken().getTokenValue());

        OAuth2User oAuth2User = super.loadUser(userRequest);
        // 위 request 정보를 토대로 강제 회원가입 진행
        // 구글로그인버튼 -> 구글로그인 창 -> 로그인 완료 -> 사용자 정보 code를 리턴 받음(userRequest에 담김) -> code를 토대로 Access Token 요청
        //
        // userRequest 정보를 토대로
        // -> 회원 프로필을 받아야함 (loadUser 함수) -> 구글로부터 회원 프로필을 받아줌
        log.info("userRequest.getAttributes : {}", super.loadUser(userRequest).getAttributes());


        String provider = userRequest.getClientRegistration().getRegistrationId();
        String provider_id = oAuth2User.getAttribute("sub"); // provid

        String email = oAuth2User.getAttribute("email");
        String username = provider + provider_id; // google_sub
        String password = bCryptPasswordEncoder.encode("getInthere");
        String role = "ROLE_USER";

        User userEntity = userRepository.findByUsername(username);

        if (userEntity == null) {
            userEntity = User.builder()
                    .username(username)
                    .email(email)
                    .password(password)
                    .provider(provider)
                    .provider_id(provider_id)
                    .role(role)
                    .build();
            userRepository.save(userEntity);
        } else {
            log.info("최초 로그인이 아닙니다.");
        }
        return new PrincipalDetails(userEntity, oAuth2User.getAttributes());
    }
}

• 구글 로그인 성공 이후 loadUser()에서 userRequest에 Access Token을 요청할 code, 사용자 정보가 담깁니다.
• 권한인 ROLE은 "ROLE_USER"로 설정하였습니다. (권한 부여)
• 이 정보를 토대로 최초 로그인 시 데이터베이스에 데이터를 삽입하고, user 정보와, userRequest의 attributes를 PrincipalDetails에 담아 리턴하였습니다.
• 최초 로그인이 아닐 경우 if문이 실행되지 않고 PrincipalDetails에 user 정보와 attribute만 담아서 리턴합니다.

---

만든 PrincipalOauthUserService는 Filter에 후처리 서비스로 등록해 줍시다.

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, // @Secured 활성화
                            prePostEnabled = true // @PreAuthorized 활성화, @PostAuthroized 활성화
)
public class SecurityConfig {
    @Autowired
    PrincipalOauth2UserService principalOauth2UserService;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.authorizeRequests()
                .antMatchers("/user/**").authenticated() // 인증
                .antMatchers("/manager/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_MANAGER')") // 인증 + 인가
                .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')") // 인증 + 인가
                .anyRequest().permitAll()
                .and()
                .formLogin()
                .loginPage("/loginForm")
                .loginProcessingUrl("/login") // login 주소가 호출이되면 시큐리티가 낚아채서 대신 로그인 진행해줌.
                .defaultSuccessUrl("/")
                .and()
                .oauth2Login()
                .loginPage("/loginForm")
                .userInfoEndpoint()
                .userService(principalOauth2UserService); // 구글 로그인 이후 후처리

        return http.build();
    }

}

---

번외 : PrincipalDetails를 OAuth2User, UserDetails 두 인터페이스를 상속받아 구현한 것처럼 PrincipalDetailsService 또한 아래와 한 군데에 묶어서 구현할 수 있습니다만 가독성을 위해 분리하였습니다.

 

PrincipalDetailsService extends DefaultOAuth2UserService(OAuth 회원) implements UserDetailsService(일반 회원)

SecurityConfig

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, // @Secured 활성화
                            prePostEnabled = true // @PreAuthorized 활성화, @PostAuthroized 활성화
)
public class SecurityConfig {

    @Autowired
    PrincipalDetailsService principalDetailsService;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.authorizeRequests()
                .antMatchers("/user/**").authenticated() // 인증
                .antMatchers("/manager/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_MANAGER')") // 인증 + 인가
                .antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')") // 인증 + 인가
                .anyRequest().permitAll()
                .and()
                .formLogin()
                .loginPage("/loginForm")
                .loginProcessingUrl("/login") // login 주소가 호출이되면 시큐리티가 낚아채서 대신 로그인 진행해줌.
                .defaultSuccessUrl("/")
                .and()
                .oauth2Login()
                .loginPage("/loginForm")
                .userInfoEndpoint()
                .userService(principalDetailsService); // 구글 로그인 이후 후처리

        return http.build();
    }

}

• userInfoEndpoint() 는 OAuth2 로그인 성공 후 사용자 정보를 가져올 때 설정을 담당합니다.
• 즉, userInfoEndpoint().userService()는 OAuth2 로그인 성공 후 사용자 정보를 가져온 상태에서 리소스 서버(Google, 네이버, 카카오 등) 에서 추가 진행하고자 하는 기능을 구현합니다.

---

일반 유저 / OAuth 를 나누지 않음으로써 생기는 장점

// 일반 로그인
@ResponseBody
@GetMapping("/test/normal/login")
public String loginTest(Authentication authentication, @AuthenticationPrincipal UserDetails userDetails) {
    log.info("/test/normal/login ===================");
    PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal(); // 다운캐스팅 하거나,
    log.info("authentication : {}", principalDetails.getUser());
    log.info("userDetails : {}", userDetails.getUsername()); // 어노테이션으로 하거나
    return "세션 정보 확인하기";
}

// OAuth 로그인
@ResponseBody
@GetMapping("/test/oauth/login")
public String loginTestOauth(Authentication authentication, @AuthenticationPrincipal OAuth2User oauth) {
    log.info("/test/oauth/login ===================");
    OAuth2User oAuth2User = (OAuth2User) authentication.getPrincipal();// 다운캐스팅 하거나,
    log.info("authentication : {}", oAuth2User.getAttributes());
    log.info("oauth2User : {} ", oauth.getAttributes()); // 어노테이션으로 하거나

    return "Oauth 세션 정보 확인하기";
}

• 위에서 PrincipalDetails를 UserDetails만 상속하여 일반 유저로 제한한 것이 아닌, OAuth2User까지 상속한 덕분에 Controller에서는 이렇게 일반/소셜 로그인을 요청매핑을 나누지 않아도 됩니다.

// 일반 로그인/OAuth 로그인 나누지 않고 상속처리
// UserDetails -> PrincipalDetails
// OAuthUser -> PrincipalDetails
@ResponseBody
@GetMapping("/test/login")
public String loginTest(@AuthenticationPrincipal PrincipalDetails principalDetails) {
    log.info("/test/login ===================");
    log.info("principalDetails : {}", principalDetails.getUser());
    return "Oauth 또는 일반 로그인 세션 정보 확인하기";
}

• 위와 같이 하나의 요청으로 묶어서 처리할 수 있게 되었습니다.
• OAuth2 로그인 후처리 서비스에서 등록한 @AuthenticationPricinpal 어노테이션 : 세션 정보 UserDetails에 접근할 수 있는 어노테이션으로, 로그인 정보를 컨트롤러 계층에서 받아올 수 있습니다.

 

 

<정리>

• OAuth2.0을 이용한 소셜 로그인 성공 이후 후처리(권한부여 및 최초 로그인 시 데이터베이스 삽입)
• OAuth를 정확히 이해하기 위해서 일반 로그인 로직을 잘 이해하는 것이 필수입니다.

 

<참고 자료>

Spring Security #3 아키텍처 이해하기, 인증 및 인가 원리

 

[스프링 시큐리티] @AuthenticationPrincipal 로그인 정보 받아오기