Spring Security

Spring🌸

Spring Security - 기본

Jeein0313 2023. 5. 20. 19:59

웹 애플리케이션을 공격하는 세션 고정 공격, 클릭재킹 공격, CSRF 등의 보안 취약점을 고려하기 위해서는 Spring Security라는 보안 프레임워크를 이용할 수 있다.

*세션 고정 공격(Session Fixation) : 공격자가 유효한 사용자의 세션을 가로채도록 허용하는 공격. 이 공격은 웹 애플리케이션이 session ID, 특히 취약한 웹 애플리케이션을 관리하는 방식의 한계를 탐색한다. 사용자 인증 시 새로운 session ID를 할당하지 않으므로(로그인 시 발급받은 세션 ID가 로그인 전/후 모두 동일하게 사용됨) 기존 session ID를 사용할 수 있으며, 공격은 유효한 session ID를 얻은 후 해당 세션 ID로 사용자를 인증하도록 유도하고, 사용된 session ID 를 알아내어 사용자가 인증한 세션을 탈취하는 것으로 구성된다.

세션 고정 공격은 사용자가 로그인 한 후에 클라이언트와 웹 서버 간에 수립된 세션을 도청하는 세션 하이재킹의 일종이 아니며, 피해자의 브라우저에 established된 세션을 fix 시키므로 사용자가 로그인하기 전에 공격이 시작된다.

*클릭재킹 공격 : 웹 사용자가 자신이 클릭하고 있다고 인지하는 것과 다른 어떤 것을 클릭하게 속이는 악의적인 기법으로써 잠재적으로 공격자는 비밀정보를 유출시키거나 그들의 컴퓨터에 대한 제어를 획득할 수 있게 된다.(사용자를 속여 보이지 않는 요소를 클릭하도록 할 때 발생함)

해킹된 사이트를 클릭하면 다른 불량 iframe 웹 사이트에서 작업이 실행되고, 이러한 클릭으로 인해 사용자 삭제, 권한 업데이트 또는 기타 작업이 발생할 수 있다.

예를 들어, 어떤 비디오에 링크된 이메일을 받았을 경우, 사용자가 플레이 버튼을 누를 때 이는 아마존의 상품 페이지이 상품 구매 버튼을 누르는 것일 수 있다.

*CSRF는 https://nothing-is-on-my-way.tistory.com/83 참고.

Spring Security란 Spring MVC 기반 애플리케이션 인증과 인가 기능을 지원하는 보안 프레임워크이다.

Spring MVC 기반 애플리케이션 보안을 적용하기 위한 사실상의 표준이다.

Spring에서 지원하는 Interceptor나 Servlet Filter를 사용해서 보안 기능을 직접 구현할 수도 있지만, 웹 애플리케이션의 보안의 대부분의 기능을 Spring Security에서 안정적으로 지원하고 있으므로 구조적으로 잘 만들어진 검증된 Spring Security를 이용하는 것이 안전한 선택이라고 볼 수 있다.

Spring Security로 할 수 있는 보안 강화 기능은 다음과 같다.

다양한 유형(폼 로그인 인증, 토큰 기반 인증, OAuth 2 기반 인증, LADP 인증)의 사용자 인증 기능 적용
애플리케이션 사용자의 역할(Role)에 따른 권한 레벨 적용
애플리케이션에서 제공하는 리소스에 대한 접근 제어
민감한 정보에 대한 데이터 암호화
SSL 적용
일반적으로 알려진 웹 보안 공격 차단

이 외에도 SSO, 클라이언트 인증서 기반 인증, 메서드 보안, 접근 제어 목록 같은 보안을 위한 기능을 지원한다.

Spring Security에서 사용하는 용어 정리

Principal(주체)
- Spring Security에서 사용되는 Principal 은 애플리케이션에서 작업을 수행할 수 있는 사용자, 디바이스 또는 시스템 등이 될 수 있으며, 일반적으로 인증 프로세스가 성공적으로 수행된 사용자의 계정 정보를 의미

Authentication(인증)
- 애플리케이션을 사용하는 사용자가 본인이 맞음을 증명하는 절차를 의미.
- Authentication (인증)을 위해서는 Credential(시원 증명 정보)가 필요하다.
- 특정 사이트의 로그인을 위해 입력하는 패스워드 역시 Credential

Authorization(인가, 권한 부여)
- Authentication이 정상적으로 수행된 사용자에게 하나 이상의 권한(authority)을 부여하여 특정 애플리케이션의 특정 리소스에 접근할 수 있게 허가하는 과정을 의미.
- Authorization은 Authentication 과정 이후 수행되어야 하며 권한은 일반적으로 역할(Role) 형태로 부여된다.

Access Control
- 사용자가 애플리케이션의 리소스에 접근하는 행위를 제어하는 것을 의미한다.

Hello, Spring Security 샘플 애플리케이션으로 Spring Security의 기본 구조를 알아보자.

Security의 기본 구조와 동작 방식을 가장 이해하기 쉬운 SSR 방식으로 샘플 애플리케이션을 만들어보자.

Hello Spring Security 샘플 애플리케이션의 Home 화면은 다음과 같다.

회원 가입 화면은 다음과 같다.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      layout:decorate="layouts/common-layout">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>Hello Spring Security Coffee Shop</title>
</head>
<body>
    <hr />
    <div class="container" layout:fragment="content">
        <!-- (1) 회원 가입 폼 -->
        <form action="/members/register" method="post">
            <div class="row">
                <div class="col-xs-2">
                    <input type="text" name="fullName" class="form-control" placeholder="User Name"/>
                </div>
            </div>
            <div class="row" style="margin-top: 20px">
                <div class="col-xs-2">
                    <input type="email" name="email" class="form-control" placeholder="Email"/>
                </div>
            </div>
            <div class="row" style="margin-top: 20px">
                <div class="col-xs-2">
                    <input type="password" name="password" class="form-control" placeholder="Password"/>
                </div>
            </div>

            <button class="btn btn-outline-secondary" style="margin-top: 20px">회원 가입</button>
        </form>
    </div>
</body>
</html>

(1)의 HTML form 태그를 이용해서 회원 가입 폼을 구성하며 해당 폼에서 입력한 정보는 아래의 코드에서 MemberController의 registerMember() 핸들러 메서드를 통해 데이터베이스에 저장된다.

package com.codestates.member;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@Controller
@RequestMapping("/members")
public class MemberController {
    private final MemberService memberService;
    private final MemberMapper mapper;

    public MemberController(MemberService memberService, MemberMapper mapper) {
        this.memberService = memberService;
        this.mapper = mapper;
    }

    @GetMapping("/register")
    public String registerMemberForm() {
        return "member-register";
    }

    @PostMapping("/register")
    public String registerMember(@Valid MemberDto.Post requestBody) {
        Member member = mapper.memberPostToMember(requestBody);
        memberService.createMember(member);

        System.out.println("Member Registration Successfully");
        return "login";
    }

    @GetMapping("/my-page")
    public String myPage() {
        return "my-page";
    }
}

로그인 화면은 다음과 같다.

커피 보기 화면은 다음과 같다.

전체 주문 목록 보기 화면은 다음과 같다.

Spring Security를 적용했을 때, 관리자만 접근할 수 있도록 설정해주면 된다.

마이페이지 화면은 다음과 같다.

마이페이지 화면은 Spring Security를 적용했을 때, 일반 사용자만 접근할 수 있는 페이지이어야 한다.

이제 샘플 애플리케이션에 Spring Security 의존 라이브러리를 추가해보자.

build.gradle의 dependencies에 다음과 같이 spring-boot-starter-security 를 추가한다.

dependencies {
	...
  ...

	implementation 'org.springframework.boot:spring-boot-starter-security'   // (1)
  
  ...
  ...
}

그리고 서버를 실행하여 localhost:8080/login에 접속하면 아래와 같은 화면이 나타난다.

이 화면은 우리가 직접 만든 로그인 페이지가 아니며, 바로 Spring Security에서 자동 구성을 통해 내부적으로 제공해주는 디폴트 로그인 페이지이다. 그리고 Username과 password 역시 디폴트 값이 아래와 같이 정해져 있다.

✔️ Spring Security에서 제공해주는 디폴트 로그인 정보

Username : 'user'
Password : 아래와 같이 서버의 로그에서 확인 가능

하지만 이 방식은 애플리케이션을 실행할 때마다 패스워드가 변경되며, Spring Security에서 제공하는 디폴트 인증 정보만으로는 회원 각자의 인증 정보로 로그인 할 수 없다.

따라서 Spring Security의 Configuration을 통해 우리에게 맞는 인증 방식을 설정해보자.

Spring Security Configuration의 기본 구조는 다음과 같다.

package com.codestates.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class SecurityConfiguration {
    // 여기에 Spring Security의 설정을 진행합니다.
}

여기에 InMemory User로 인증할 수 있도록 설정 정보를 작성해보면 다음과 같이 작성할 수 있다.

package com.codestates.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;

@Configuration
public class SecurityConfiguration {

    @Bean
    public UserDetailsManager userDetailsService(){
        UserDetails userDetails =
                User.withDefaultPasswordEncoder()
                        .username("jeein@naver.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        return new InMemoryUserDetailsManager(userDetails);
    }

}

위 코드를 작성하며, 사용자의 계정 정보를 메모리상에 지정했기 때문에 애플리케이션이 실행될 때마다 사용자 계정 정보가 바뀔 일은 없다.

UserDetails 인터페이스는 인증된 사용자의 핵심 정보를 담고 있으며, UserDetails 구현체인 User 클래스를 이용해 사용자의 인증 정보를 생성하고 있다.

withDefaultPasswordEncoder()는 디폴트 패스워드 인코더를 이용해 사용자의 패스워드를 암호화한다.
username() 메서드는 사용자의 username을 설정한다. (여기서 username은 회원명이 아니라, 회원을 식별할 수 있는 사용자 아이디 같은 값)
password() 메서드는 사용자의 password를 설정한다.
roles() 메서드는 사용자의 Role, 즉 역할을 지정하는 메서드이다.

Spring Security에서는 사용자의 핵심 정보를 포함한 UserDetails를 관리하는 UserDetailsManager라는 인터페이스를 제공한다.

그런데 우리는 메모리상에서 UserDetails를 관리하므로 InMemoryUserDetailsManager라는 구현체를 사용한다.

*UseDetails 인터페이스

UserDetails 인터페이스는 핵심 사용자 정보를 제공하며, 이를 구현한 클래스는 Spring Security에서 직접적으로 보안을 목적으로 사용되지는 않는다. 구현 클래스는 단순히 사용자 정보를 저장하는 것이고, 이 정보는 나중에 인증(Authentication) 객체로 캡슐화된다. 이를 통해 보안과 관련이 없는 사용자 정보를 편리한 위치에 저장할 수 있다.

*withDefaultPasswordEncoder : withDefaultPasswordEncoder() 메서드의 Deprecated는 특이하게도 향후 버전에서 제거됨을 의미하기 보다는 Production 환경에서 인증을 위한 사용자 정보를 고정해서 사용하지 말라는 경고의 의미를 나타내고 있는 것이니 반드시 테스트 환경이나 데모 환경에서만 사용하기 바란다.

위에 나와 있듯이 UserDetails 생성할 때에 User.withDefaultPasswordEncoder()를 사용하게 되면 소스코드에 "password"가 컴파일되고 생성 시점에 메모리에 포함되기 때문에 암호가 plain text로 노출될 수 있어서 프로덕션 환경에서는 미리 비밀번호를 해시하는 것이 좋다.

예를 들어

 PasswordEncoder encoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
 // outputs {bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
 // remember the password that is printed out and use in the next step
 System.out.println(encoder.encode("password"));
  
 
 UserDetails user = User.withUsername("user")
     .password("{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG")
     .roles("USER")
     .build();

이렇게 같이 new InMemoryUserDetailsManager(userDetails)를 통해 UserDetailsManager 객체를 Bean으로 등록하면 Spring 에서는 해당 Bean이 가지고 있는 사용자의 인증 정보가 클라이언트의 요청이 넘어올 경우, 정상적인 인증 프로세스를 수행한다.

다시 애플리케이션을 실행시키고 로그인 정보를 입력하면 정상적으로 로그인이 성공하는 것을 확인 가능하다.

하지만 실제 서비스에서 이렇게 사용자 계정 정보를 고정하여 사용할 수는 없다. 실제로는 사용자 계정 정보가 데이터베이스에 저장되어야 한다.

다음으로 Spring Security에서 HTTP 보안을 설정하기 위한 기본 코드를 작성해 보자.

이때 우리가 만든 custom 로그인 페이지를 사용할 수 있도록 설정을 추가해보자.

package com.codestates.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        //HttpSecurity를 통해 HTTP 요청에 대한 보안 설정 구성
        http
                .csrf().disable() //(1)
                .formLogin() //(2)
                .loginPage("/auths/login-form") //(3)
                .loginProcessingUrl("/process_login") //(4)
                .failureUrl("/auths/login-form?error") //(5)
                .and() //(6)
                .authorizeHttpRequests() //(7)
                .anyRequest() //(8)
                .permitAll(); //(9)
        
        return http.build();

    }

    @Bean
    public UserDetailsManager userDetailsService(){
        UserDetails userDetails =
                User.withDefaultPasswordEncoder()
                        .username("jeein@naver.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        return new InMemoryUserDetailsManager(userDetails);
    }

}

(1)에서는 CSRF(Cross-Site Reqeust Forgery) 공격에 대한 Spring Security 설정을 비활성화하고 있다. Spring Security는 기본적으로 아무 설정하지 않으면 csrf() 공격을 방지하기 위해 클라이언트로부터 CSRF Token을 수신 후 검증한다.
(2)에서는 formLogin()을 통해 기본적인 인증 방법을 폼 로그인 방식으로 지정한다.
(3)의 loginPage()에서는 우리가 만들어 둔 custom 로그인 페이지를 사용하도록 설정한다.
(4)의 loginProcessingUrl("/process_login") 메서드를 통해 로그인 인증 요청을 수행할 요청 URL을 지정한다. loginProcessing()의 파라미터인 "/process_login"은 우리가 만들어 둔 login.html의 form 태그의 action 속성에 지정한 URL과 동일하다. 아직 우리는 AuthController에 별도의 인증 프로세스 로직을 지정하지 않았다. 결국 /process_login URL로 요청을 전송하면 여전히 Spring Security에서 내부적으로 인증 프로세스를 진행하는 것이다.
(5)의 failureUrl("/auth/login-form?error") 메서드를 통해 로그인 인증이 실패할 경우 어떤 화면으로 리다이렉트할 것인가를 지정한다.

로그인에 실패할 경우, 로그인 화면을 표시하고 로그인 인증에 실패했다는 메시지를 표시해 주는 것이 가장 자연스러움으로 failureUrl()의 파라미터로 커스텀 로그인 페이지의 URL인 "/auths/login-form?error"를 지정한다.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      layout:decorate="layouts/common-layout">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Hello Spring Security Coffee Shop</title>
    </head>
    <body>
        <div class="container" layout:fragment="content">
            <form action="/process_login" method="post">
                <!-- (1) 로그인 실패에 대한 메시지 표시 -->
                <div class="row alert alert-danger center" role="alert" th:if="${param.error != null}">
                    <div>로그인 인증에 실패했습니다.</div>
                </div>
                <div class="row">
                    <div class="col-xs-2">
                        <input type="email" name="username"  class="form-control" placeholder="Email" />
                    </div>
                </div>
                <div class="row" style="margin-top: 20px">
                    <div class="col-xs-2">
                        <input type="password" name="password"  class="form-control" placeholder="Password" />
                    </div>
                </div>

                <button class="btn btn-outline-secondary" style="margin-top: 20px">로그인</button>
            </form>
            <div style="margin-top: 20px">
                <a href="/members/register">회원가입</a>
            </div>
        </div>
    </body>
</html>

(1)을 보면 ${param.error} 의 값을 통해 로그인 인증 실패 메시지 표시 여부를 결정하고 있다.

${param.error} 는 Spring Security Configuration에서 failureUrl(”/auths/login-form?error”)의 ?error 부분에 해당하는 쿼리 파라미터를 의미한다.

(7)의 authorizeHttpRequests() 메서드를 통해 클라이언트의 요청이 들어오면 접근 권한을 확인하겠다고 정의한다.
(8), (9)의 anyRequest().permitAll() 메서드를 통해 클라이언트의 모든 요청에 대한 접근을 허용한다.

그럼 다음으로 request URI에 접근 권한을 부여해보자.

사용자에게 부여된 Role을 이용해서 샘플 애플리케이션의 request URI에 접근 권한을 부여해보도록 하자.

package com.codestates.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        //HttpSecurity를 통해 HTTP 요청에 대한 보안 설정 구성
        http
                .csrf().disable()
                .formLogin()
                .loginPage("/auths/login-form")
                .loginProcessingUrl("/process_login")
                .failureUrl("/auths/login-form?error")
                .and()
                .exceptionHandling().accessDeniedPage("/auth/access-denied") //(1)
                .and()
                .authorizeHttpRequests(authorize -> authorize //(2)
                        .antMatchers("/orders/**").hasRole("ADMIN") //(2-1)
                        .antMatchers("/members/my-page").hasRole("USER") //(2-2)
                        .antMatchers("/**").permitAll() //(2-3)
                );

        return http.build();

    }

    @Bean
    public UserDetailsManager userDetailsService(){
        UserDetails userDetails =
                User.withDefaultPasswordEncoder()
                        .username("jeein@naver.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        return new InMemoryUserDetailsManager(userDetails);
    }

}

(1)에서는 exceptionHandling().accessDeniedPage("auth/access-denied")를 통해 권한이 없는 사용자가 특정 request URI에 접근할 경우, 발생하는 403 에러를 처리하기 위한 페이지를 설정함.

exceptionHandling() 메서드는 메서드의 이름 그대로 Exception을 처리하는 기능을 하며, 리턴하는 ExceptionHandlingConfigurer 객체를 통해 구체적인 Exception 처리를 할 수 있다.

accessDeniedPage() 메서드는 403 에러 발생 시, 파라미터로 지정한 URL로 리다이렉트 되도록 해준다.

authorizeHttpRequest() 메서드는 (2)와 같이 람디 표현식을 통해 request URI 에 대한 접근 권한을 부여 가능하다.

antMatchers() 메서드는 이름 그대로 ant 라는 빌드 툴에서 사용되는 Path Pattern을 이용하여 매치되는 URL을 표현한다.

(2-1)의 .antMatchers(”/orders/**”).hasRole(”ADMIN”)은 ADMIN Role을 부여받은 사용자만 /orders로 시작하는 모든 URL에 접근할 수 있다는 의미.

/orders/**에서 **은 /orders로 시작하는 모든 하위 URL을 포함한다.

예를 들어, /orders/1, /orders/1/coffees, /orders/1/coffee/1 과 같은 모든 하위 URL을 포함한다.

(2-2)의 antMatchers("/members/my-page").hasRole("USER")은 USER Role을 부여받은 사용자만 /members/my-page URL에 접근할 수 있다.

(2-3)의 .anyMatchers("/**").permitAll()은 앞에서 지정한 URL 외의 나머지 모든 URL은 Role 상관없이 접근 가능함을 나타냄.

antMatchers()를 이용한 접근 권한 부여 시에는 다음을 주의하여야 한다.

.authorizeHttpRequests(authorize -> authorize
                    .antMatchers("⁄**").permitAll() // 이 표현식이 제일 앞에 오면?
                    .antMatchers("/orders/**").hasRole("ADMIN")
                    .antMatchers("/members/my-page").hasRole("USER")
            );

이처럼 .antMatchers("/**").permitAll()이 먼저 오면 Spring Security에서는 Role에 상관없이 모든 request URL에 대한 접근을 허용하기 때무에 다음에 오는 .antMatchers("/orders/**").hasRole("ADMIN")과 .antMatchers("/members/my-page").hasRole("USER")는 제 기능을 하지 못하게 되고, 결과적으로 사용자의 Role과는 무관하게 모든 request URL에 접근할 수 있게 된다.

현재 우리가 작성한 SecurityConfiguration 클래스에는 USER Role을 가지는 하나의 사용자만 InMemory User로 등록된 상태이다.

이제 ADMIN Role을 가지는 사용자를 하나 더 추가해서 .antMatchers("/orders/**").hasRole("ADMIN")로 설정한 화면에 접근할 수 있는지 확인을 해보도록 하자.

	
    @Bean
    public UserDetailsManager userDetailsService(){
        UserDetails user =
                User.withDefaultPasswordEncoder()
                        .username("jeein@naver.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        //(1)
        UserDetails admin =
                User.withDefaultPasswordEncoder()
                        .username("admin@naver.com")
                        .password("2222")
                        .roles("ADMIN")
                        .build();
        

        return new InMemoryUserDetailsManager(user,admin);
    }

(1)과 같이 admin@naver.com이라는 InMemory User를 하나 더 추가하였으며, admin@naver.com 에게는 ADMIN Role이 부가되었다.

애플리케이션을 다시 실행하고 샘플 애플리케이션의 메인 화면에서 [전체 주문 목록 보기] 메뉴를 클릭하면 정상적으로 접근이 가능한 것을 확인할 수 있다.

현재 화면에서는 사용자가 로그인한 후에 어떤 사용자가 로그인했는지 알 수 없다. 또한 로그인한 사용자가 로그아웃을 할 수 있는 기능도 없다. 그리고 마이페이지 링크 역시 로그인 한 사용자에게만 보이는 것이 좋을 것 같다.

<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"> <!-- (1) -->
    <body>
        <div align="right" th:fragment="header">
            <a href="/members/register" class="text-decoration-none">회원가입</a> |
            <span sec:authorize="isAuthenticated()"> <!-- (2) -->
                <span sec:authorize="hasRole('USER')">  <!-- (3) -->
                    <a href="/members/my-page" class="text-decoration-none">마이페이지</a> |
                </span>
                <a href="/logout" class="text-decoration-none">로그아웃</a>  <!-- (4) -->
                <span th:text="${#authentication.name}">홍길동</span>님  <!-- (5) -->
            </span>
            
            <span sec:authorize="!isAuthenticated()"> <!-- (6) -->
                <a href="/auths/login-form" class="text-decoration-none">로그인</a>
            </span>
        </div>
    </body>
</html>

로그아웃 및 권한별로 메뉴 표시를 하기 위해 수정한 header.html

타임리프 기반의 HTML 템플릿에서 사용자의 인증 정보나 권한 정보를 이용해 어떤 로직을 처리하기 위해서는 먼저 (1)과 같이 sec 태그를사용하기 위한 XML 네임스페이스를 지정한다.

네임스페이스를 지정하지 않아도 동작하지만, IDE에서 빨갛게 표시된다.

(2)와 같이 태그 내부에서 sec:authorize="isAuthenticated()"을 지정하면 현재 페이지에 접근한 사용자가 인증에 성공한 사용자인지를 체크한다. 즉, isAuthenticated()의 값이 true이면 태그 하위에 포함된 콘텐츠를 화면에 표시한다.

마이페이지의 경우, ADMIN Role을 가진 사용자는 필요 없는 기능이므로 (3)과 같이 sec:authorize="hasRole('USER')"을 지정해서 User Role을 가진 사용자에게만 표시되도록 한다.

(2)에서 isAuthenticated()의 값이 true라는 의미는 이미 로그인한 사용자라는 의미로 [로그인] 메뉴 대신에 (4)와 같이 [로그아웃] 메뉴를 표시한다. (4)의 href="/logout"에서 "/logout" URL은 SecurityConfiguration 클래스에서 설정한 값과 같아야 한다.

(5)에서는 th:text="${#authentication.name}"를 통해 로그인 사용자의 username을 표시하고 있다. 이곳에는 우리가 로그인할 때 사요한 username이 표시된다.

(6)에서는 sec:authorize-"!isAuthenticated()"를 통해 로그인한 사용자가 아니라면 [로그인] 버튼이 표시되도록 한다.

*sec 태그를 사용하기 위해서는 build.gradle의 dependencies()에 다음의 의존라이브러리를 추가해야 한다.

implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity5’

마지막으로 Spring Security에서 로그아웃 기능을 사용하기 위한 설정을 해보자.

	
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        //HttpSecurity를 통해 HTTP 요청에 대한 보안 설정 구성
        http
                .csrf().disable()
                .formLogin()
                .loginPage("/auths/login-form")
                .loginProcessingUrl("/process_login")
                .failureUrl("/auths/login-form?error")
                .and()
                .logout() //(1)
                .logoutUrl("/logout") //(2) 
                .logoutSuccessUrl("/") //(3)
                .and()
                .exceptionHandling().accessDeniedPage("/auth/access-denied")
                .and()
                .authorizeHttpRequests(authorize -> authorize
                        .antMatchers("/orders/**").hasRole("ADMIN")
                        .antMatchers("/members/my-page").hasRole("USER")
                        .antMatchers("/**").permitAll()
                );

        return http.build();

    }

로그아웃에 대한 추가 설정을 위해서는 (1)과 같이 logout()을 먼저 호출해야 한다. logout() 메서드는 로그아웃 설정을 위한 LogoutConfigurer 를 리턴한다.

(2)에서는 logoutUrl("/logout")을 통해 사용자가 로그아웃을 수행하기 위한 request URL을 지정한다.

(3)에서는 로그아웃을 성공적으로 수행한 이후 리다이렉트할 URL을 지정한다. 여기서는 로그아웃 이후 샘플 애플리케이션의 메인 화면으로 리다이렉트 하도록 지정했다.

여기까지 InMemory User를 이용해 애플리케이션 실행 시, 메모리에 두 개의 사용자 정보를 미리 등록하여 사용자 권한 별로 request URL의 접근이 제한되는지 여부를 살펴보았다.

하지만 정상적으로 동작하지 않는 기능이 있는데, 바로 회원가입이다.

우리는 아직 샘플 애플리케이션에서 회원 가입 요청으로 전달받은 회원 정보를 Spring Security가 알 수 있는 어떤 처리도 하지 않았다.

회원 가입 폼을 통한 InMemory User 를 등록하기 위한 작업 순서는 다음과 같다.

PasswordEncoder Bean 등록
MemberService Bean 등록을 위한 JavaConfiguration 작성
InMemoryMemberService 클래스 구현

먼저 PasswordEncoder를 Bean 등록해보자.

PasswordEncoder는 Spring Security에서 제공하는 패스워드 암호화 기능을 제공하는 컴포넌트이다.

우리가 회원 가입 폼을 통해 애플리케이션에 전달하는 패스워드는 암호화되지 않은 plain text이다.

따라서 회원 가입 폼에서 전달받은 패스워드는 InMemory User로 등록되기 전에 암호화되어야 한다.

PasswordEncoder는 다양한 암호화 방식을 사용하며, Spring Security에서 지원하는 PasswordEncoder의 디폴트 암호화 알고리즘은 bcrypt 이다.

package com.codestates.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        //HttpSecurity를 통해 HTTP 요청에 대한 보안 설정 구성
        http
                .csrf().disable()
                .formLogin()
                .loginPage("/auths/login-form")
                .loginProcessingUrl("/process_login")
                .failureUrl("/auths/login-form?error")
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessUrl("/")
                .and()
                .exceptionHandling().accessDeniedPage("/auth/access-denied")
                .and()
                .authorizeHttpRequests(authorize -> authorize
                        .antMatchers("/orders/**").hasRole("ADMIN")
                        .antMatchers("/members/my-page").hasRole("USER")
                        .antMatchers("/**").permitAll()
                );

        return http.build();

    }

    @Bean
    public UserDetailsManager userDetailsService(){
        UserDetails user =
                User.withDefaultPasswordEncoder()
                        .username("jeein@naver.com")
                        .password("1111")
                        .roles("USER")
                        .build();

        //(1)
        UserDetails admin =
                User.withDefaultPasswordEncoder()
                        .username("admin@naver.com")
                        .password("2222")
                        .roles("ADMIN")
                        .build();


        return new InMemoryUserDetailsManager(user,admin);
    }

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

}

SecurityConfiguration 클래스에서 PasswordEncoder를 Bean으로 등록하고 있다.

PasswordEncoderFactories.createDelegatingPasswordEncoder(); 를 통해서 DelegatingPasswordEncoder를 먼저 생성하는데, 이 DelegatingPasswordEncoder가 실질적으로 PasswordEncoder 구현 객체를 생성해준다.

우리가 userDetailsService() 메서드에서 미리 생성하는 InMemoryUser 패스워드는 내부적으로 디폴트 PasswordEncoder를 통해 암호화된다.

MemberServcie Bean 등록을 위한 JavaConfiguration 작성

package com.codestates.member;

public interface MemberService {
    Member createMember(Member member);
}

Hello Spring Security 샘플 애플리케이션은 회원 가입 폼에서 전달받은 정보를 이용해 새로운 사용자를 추가하는 기능만 있으면 되므로 createMember() 하나만 구현하는 구현체가 있으면 된다.

InMemory User 등록을 위한 InMemoryMemberService 클래스

package com.codestates.member;

public class InMemoryMemberService implements MemberService {
    public Member createMember(Member member) {

        return null;
    }
}

데이터베이스에 User를 등록하기 위한 DBMemberService 클래스

package com.codestates.member;

import org.springframework.transaction.annotation.Transactional;

@Transactional
public class DBMemberService implements MemberService {
    public Member createMember(Member member) {
         return null;
    }
}

JavaConfiguration 구성

package com.codestates.config;

import com.codestates.member.InMemoryMemberService;
import com.codestates.member.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.UserDetailsManager;

@Configuration
public class JavaConfiguration {
    // (1)
    @Bean
    public MemberService inMemoryMemberService(UserDetailsManager userDetailsManager, 
                                               PasswordEncoder passwordEncoder) {
        return new InMemoryMemberService(userDetailsManager, passwordEncoder);
    }
}

JavaConfiguration 클래스는 MemberService 인터페이스의 구현 클래스인 InMemoryMemberService를 Spring Bean으로 등록한다.

(1)에서는 MemberService 인터페이스의 구현체인 InMemoryMemberService 클래스의 Bean 객체를 생성한다.

InMemoryMemberService 클래스는 데이터베이스 연동 없이 메모리에 Spring Security의 User를 등록해야 하므로 UserDetailsManager객체가 필요하다. 또한 User 등록 시 패스워드를 암호화한 후에 등록해야 하므로 Spring Security에서 제공하는 PasswordEncoder 객체가 필요하다.

이제 InMemoryMemberService를 구현해보자.

package com.codestates.member;

import com.codestates.auth.utils.AuthorityUtils;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.UserDetailsManager;

import java.util.List;

public class InMemoryMemberService implements MemberService {  // (1)
    private final UserDetailsManager userDetailsManager;
    private final PasswordEncoder passwordEncoder;

    // (2)
    public InMemoryMemberService(UserDetailsManager userDetailsManager, PasswordEncoder passwordEncoder) {
        this.userDetailsManager = userDetailsManager;
        this.passwordEncoder = passwordEncoder;
    }

    public Member createMember(Member member) {
        // (3)
        List<GrantedAuthority> authorities = createAuthorities(Member.MemberRole.ROLE_USER.name());

        // (4)
        String encryptedPassword = passwordEncoder.encode(member.getPassword());

        // (5)
        UserDetails userDetails = new User(member.getEmail(), encryptedPassword, authorities);

        // (6)
        userDetailsManager.createUser(userDetails);

        return member;
    }

    private List<GrantedAuthority> createAuthorities(String... roles) {
        // (3-1)
        return Arrays.stream(roles)
                .map(role -> new SimpleGrantedAuthority(role))
                .collect(Collectors.toList());
    }
}

InMemoryMemberService 클래스는 MemberService 인터페이스를 구현하는 구현 클래스이므로 (1)과 같이 implements MemberService를 지정한다.

(2)에서는 UserDetailsManager와 PasswordEncoder를 DI 받는다.

UserDetailsManager는 Spring Security의 User를 관리하는 역할을 한다. 우리가 SecurityConfiguration에서 Bean으로 등록한 UserDetailsManager는 InMemoryUserDetailsManager 이므로 여기서 DI 받은 UserDetailsManager의 하위 타입은 InMemoryUserDetailsManager이다.
PasswordEncoder는 Spring Secrutiy User를 등록할 때 패스워드를 암호화해주는 클래스이다. Spring Security 5에서는 InMemory User도 패스워드 암호화가 필수이다.

Spring Security에서 User를 등록하기 위해서는 해당 User의 권한(Authority)를 지정해 주어야 한다.

따라서 createAuthorities(Member.MemberRole.ROLE_USER.name());을 이용해 User의 권한 목록을 List<GrantedAuthority>로 생성하고 있다.

Member 클래스에는 MemberRole이라고 하는 enum이 정해져 있고, ROLE_USER, ROLE_ADMIN 이라는 enum 타입이 정의되어 었다.

Spring Security에서는 SimpleGrantedAuthority를 사용해 Role 베이스 형태의 권한을 지정할 때, 'ROLE_'+권한명 형태로 지정해 주어야 한다. (그렇지 않을 경우, 적절한 권한 매핑이 이루어지지 않음)

(3-1)에서는 Java의 Stream API를 사용해 생성자 파라미터로 해당 User의 Role을 전달하면서 SimpleGrantedAuthority 객체를 생성한 후, List<SimpleGrantedAuthority> 형태로 리턴해 준다.

(4)에서는 PasswordEncoder를 이용해 등록할 User의 패스워드를 암호화하고 있다. 만약 패스워드를 암호화하지 않고 User를 등록한다면 User 등록은 되지만, 로그인 인증 시에 다음과 같은 에러를 만나게 된다.

java.lang.IllegalArgumentException: There is no PasswordEncoder mapped for the id "null”

(5)에서는 Spring Security User로 등록하기 위해 UserDetails를 생성한다. (Spring Security에서는 User 정보를 UserDetails로 관리한다.)

이제 애플리케이션을 다시 실행하고 회원 가입 메뉴에서 화원 정보를 등록한 후, 등록한 회원 정보로 로그인을 수행하면 정상적으로 로그인이 되는 것을 확인 가능하다.

지금까지 로그인 인증 방식은 오로지 Spring Security에서 제공하는 InMemory User를 사용하는 인증 방식이다.

InMemory User는 애플리케이션을 다시 시작하면 등록했던 User 정보가 다 사라지므로, 간단한 Member 엔티티 클래스를 이용해서 회원 인증 정보를 포함한 회원 정보를 데이터베이스 테이블에서 관리하도록 해보자.

Spring Security에서는 User 인증 정보를 테이블에 저장하고, 테이블에 저장된 인증 정보를 이용해 인증 프로세스를 진행할 수 있는 몇가지 방법이 있는데, 그 중 한가지 방법이 바로 Custom UserDetailsService를 이용하는 방법이다.

*일반적으로 Spring Security에서는 인증을 시도하는 주체를 User(비슷한 의미로 Principal)라고 부른다. Principal은 User의 구체적인 정보를 의미하며, 일반적으로 Spring Security에서의 Username을 의미한다. 샘플 애플리케이션에서는 Member 엔티티 클래스가 로그인 인증 정보를 포함할 텐데 이 Member 엔티티가 Spring Security의 User 정보를 포함한다고 보면 된다.

로그인 인증을 위해 데이터베이스에 저장되어 있는 인증 정보를 사용할 것이므로, InMemory User를 위한 설정들은 더 이상 필요없으므로 제거해야 한다.

package com.codestates.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        //HttpSecurity를 통해 HTTP 요청에 대한 보안 설정 구성
        http
                .headers().frameOptions().sameOrigin() //(1)
                .and()
                .csrf().disable()
                .formLogin()
                .loginPage("/auths/login-form")
                .loginProcessingUrl("/process_login")
                .failureUrl("/auths/login-form?error")
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessUrl("/")
                .and()
                .exceptionHandling().accessDeniedPage("/auth/access-denied")
                .and()
                .authorizeHttpRequests(authorize -> authorize
                        .antMatchers("/orders/**").hasRole("ADMIN")
                        .antMatchers("/members/my-page").hasRole("USER")
                        .antMatchers("/**").permitAll()
                );

        return http.build();

    }

    //InMemory User를 위한 설정이므로 제거 대상...
//    @Bean
//    public UserDetailsManager userDetailsService(){
//        UserDetails user =
//                User.withDefaultPasswordEncoder()
//                        .username("jeein@naver.com")
//                        .password("1111")
//                        .roles("USER")
//                        .build();
//
//        //(1)
//        UserDetails admin =
//                User.withDefaultPasswordEncoder()
//                        .username("admin@naver.com")
//                        .password("2222")
//                        .roles("ADMIN")
//                        .build();
//
//
//        return new InMemoryUserDetailsManager(user,admin);
//    }

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

}

SecurityConfiguration 클래스에서 (1)은 웹 브라우저에서 H2 웹 콘솔을 정상적으로 사용하기 위한 설정이다.

frameOptions()는 HTML 태그 중에서 <frame>이나 <iframe>,<object> 태그에서 페이지를 렌더링할지의 여부를 결정하는 기능을 한다.

Spring Security에서는 클릭재킹 공격을 막기 위해서 기본적으로 frameOptions() 기능이 활성화되어 있으며 디폴트 값은 DENY이다.

즉, 위에서 언근한 HTML 태그를 이용한 페이지 렌더링을 허용하지 않겠다는 뜻이며, (1)과 같이 .frameOptions().sameOrigin()을 호출하면 동일 출처로부터 들어오는 request만 페이지 렌더링을 허용한다.

H2 웹 콘솔의 화면 자체가 내부적으로 태그를 사용하고 있으므로 개발 환경에서는 H2 웹 콘솔을 정상적으로 사용할 수 있도록 (1)과 같이 설정하면 된다.

(2)의 userDetailsService() 메서드는 InMemory User릉 등록하는 역할을 하지만, 이제 데이터베이스에서 User를 등록하고 데이터베이스에 저장된 User의 인증 정보를 사용할 것이므로 필요가 없다.

JavaConfiguration의 Bean 등록 변경

@Configuration
public class JavaConfiguration {
    // (1)
    @Bean
    public MemberService dbMemberService(MemberRepository memberRepository,
                                         PasswordEncoder passwordEncoder) {
        return new DBMemberService(memberRepository, passwordEncoder); (1-1)
    }
}

DBMemberService는 User 인증 정보를 데이터베이스에 저장하는 역할을 하는데, Spring Security 입장에서 User라고 부르는 정보는 우릭 회원 가입 시 등록하는 회원 정보 안에 포함되어 있다고 보면된다.

package com.codestates.member;

import com.codestates.exception.BusinessLogicException;
import com.codestates.exception.ExceptionCode;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

@Transactional
public class DBMemberService implements MemberService {

    private final MemberRepository memberRepository;

    private final PasswordEncoder passwordEncoder;

    public DBMemberService(MemberRepository memberRepository, PasswordEncoder passwordEncoder) {
        this.memberRepository = memberRepository;
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    public Member createMember(Member member) {
        verifyExistsEmail(member.getEmail());

        String encryptedPassword = passwordEncoder.encode(member.getPassword());
        member.setPassword(encryptedPassword);

        Member savedMember = memberRepository.save(member);

        System.out.println("# Create Member in DB");
        return savedMember;
    }

    @Override
    public Member findMember(String email){
        return null;
    }

    private void verifyExistsEmail(String email){
        Optional<Member> member = memberRepository.findByEmail(email);
        if(member.isPresent())
            throw new BusinessLogicException(ExceptionCode.MEMBER_EXISTS);
    }

}

(1)의 생성자를 통해 MemberRepository와 PasswordEncoder Bean 객체를 DI 받는다.

(2)에서 PasswordEncoder를 이용해 패스워드를 암호화한다.

(3)에서 암호화된 패스워드를 password 필드에 다시 할당한다.

다음으로 데이터베이스에서 조회한 User 인증 정보를 기반으로 인증을 처리하는 Custom UserDetailsService를 구현해 보자.

*UserDetailsService는 Spring Security에서 제공하는 컴포넌트 중 하나로 User 정보를 로드하는 핵심 인터페이스이다. 여기서 '로드'의 의미는 인증에 필요한 User 정보를 어딘가에서 가져온다는 의미이며, 여기서 말하는 '어딘가'는 메모리가 될 수도 있고, DB 등의 영구 저장소가 될 수도 있다.

우리가 InMemory User를 등록하는데 사용했던 InMemoryUserDetailsManager는 UserDetailsManager 인터페이스의 구현체이고, UserDetailsManager는 UserDetailsService를 상속하는 확장 인터페이스이다.

package com.codestates.auth;

import com.codestates.auth.utils.HelloAuthorityUtils;
import com.codestates.exception.BusinessLogicException;
import com.codestates.exception.ExceptionCode;
import com.codestates.member.Member;
import com.codestates.member.MemberRepository;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Optional;

@Component
public class HelloUserDetailsServiceV1 implements UserDetailsService { //(1)

    private final MemberRepository memberRepository;

    private final HelloAuthorityUtils authorityUtils;

    //(2)
    public HelloUserDetailsServiceV1(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    //(3)
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        //(4)
        Collection<? extends GrantedAuthority> authorities = authorityUtils.createAuthorities(findMember.getEmail());

        //(5)
        return new User(findMember.getEmail(), findMember.getPassword(), authorities);

    }
}

데이터베이스에서 조회한 인증 정보를 기반으로 인증을 처리하는 Custom UserDetailsService인 HelloUserDetailsService의 클래스 코드이다,

HelloUserDetailsService와 같은 Custom UserDetailsService를 구현하기 위해서는 (1)과 같이 UserDetailsService 인터페이스를 구현해야 한다.

HelloUserDetailsService는 데이터베이스에서 User를 조회하고, 조회한 User의 권한(Role) 정보를 생성하기 위해 (2)와 같이 MemberRepository와 HelloAuthorityUtils 클래스를 DI 받는다.

UserDetailsService 인터페이스를 implements 하는 구현 클래스는 (3)과 같이 loadUserByUserName(String username)이라는 추상 메서드를 구현해야 한다.

(4)에서는 HelloAuthorityUtils를 이용해 데이터베이스에서 조회한 회원의 이메일 정보를 이용해 Role 기반의 권한 정보(GrantedAuthority) 컬렉션을 생성한다.

데이터베이스에서 조회한 인증 정보와 (4)에서 생성한 권한 정보를 Spring Security가 알지 못하기 때문에 Spring Security에 이 정보들을 제공해 주어야 하며, (5)에서는 UserDetails 인터페이스의 구현체인 User 클래스의 객체를 통해 제공하고 있다.

(5)와 같이 데이터베이스에서 조회한 User 클래스의 객체를 리턴하면 Spring Security가 이 정보를 이용해 인증 절차를 수행한다.

즉, 데이터베이스에서 User 인증 정보만 Spring Security에게 넘겨주고, 인증 처리는 Spring Security가 대신 해준다.

UserDetails는 UserDetailsService에 의해 로드되어 인증을 위해 사용되는 핵심 User 정보를 표현하는 인터페이스이다. UserDetails 인터페이스의 구현체는 Spring Security에서 보안 정보 제공을 목적으로 직접 사용되지는 않고, Authentication 객체로 캡슐화되어 제공된다.

HelloAuthorityUtils의 코드는 아래와 같다.

package com.codestates.auth.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class HelloAuthorityUtils {
    // (1)
    @Value("${mail.address.admin}")
    private String adminMailAddress;

    // (2)
    private final List<GrantedAuthority> ADMIN_ROLES = AuthorityUtils.createAuthorityList("ROLE_ADMIN", "ROLE_USER");

    // (3)
    private final List<GrantedAuthority> USER_ROLES = AuthorityUtils.createAuthorityList("ROLE_USER");
    
    public List<GrantedAuthority> createAuthorities(String email) {
        // (4)
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES;
        }
        return USER_ROLES;
    }
}

HelloUserDetailsService에서 Role 기반의 User 권한을 생성하기 위한 HelloAuthorityUtils 코드이다.

(1)은 application.yml에서 추가한 프로퍼티를 가져오는 표현식이고, (1)과 같이 @Value("${프로퍼티 경로}") 표현식 형태로 작성하면 application.yml 에 정의되어 있는 프로퍼티의 값을 클래스 내에서 사용할 수 있다.

(1)에서는 applicaiton.yml 에 미리 정의한 관리자 권한을 가질 수 있는 이메일 주소를 불러오고 있다.

application.yml 파일에 정의한 관리자용 이메일 주소는 회원 등록 시, 특정 이메일 주소에 관리자 권한을 부여할 수 있는지를 결정하기 위해 사용된다.

application.yml 파일에는 다음과 같이 관리자 이메일 주소를 정의해야 한다.

mail:
  address:
    admin: admin@naver.com

(2)에서는 Spring Security에서 지원하는 AuthorityUtils 클래스를 이용하여 관리자용 권한 목록을 List<GrantedAuthority> 객체로 미리 생성한다.

관리자 권한일 경우, 일반 사용자의 권한까지 추가로 포함되어 있다.

(3)에서는 Spring Security에서 지원하는 AuthorityUtils 클래스를 이용하여 일반 사용 권한 목록을 List<GrantedAuthority> 객체로 미리 생성한다.

(4)에서는 파라미터로 전달받은 이메일 주소가 application.yml 파일에서 가져온 관리자용 이메일 주소와 동일하다면 관리자용 권한인 List<GrantedAuthority> ADMIN_ROLES를 리턴한다.

실무에서는 관리자 권한 부여를 위한 추가적인 인증 절차가 필요하다.

조금 더 유연하고 깔끔한 코드의 구성을 위해 앞에서 작성한 HelloUserDetailsService 클래스를 살짝 개선해보자.

package com.codestates.auth;

import com.codestates.auth.utils.HelloAuthorityUtils;
import com.codestates.exception.BusinessLogicException;
import com.codestates.exception.ExceptionCode;
import com.codestates.member.Member;
import com.codestates.member.MemberRepository;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Optional;

@Component
public class HelloUserDetailsServiceV2 implements UserDetailsService { 

    private final MemberRepository memberRepository;

    private final HelloAuthorityUtils authorityUtils;

    
    public HelloUserDetailsServiceV2(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        //(1) 개션된 부분
        return new HelloUserDetails(findMember);
    }
    
    //(2) HelloUserDetails 클래스 추가
    private final class HelloUserDetails extends Member implements UserDetails{ //(2-1)
        
        //(2-2)
        HelloUserDetails(Member member){
            setMemberId(member.getMemberId());
            setFullName(member.getFullName());
            setEmail(member.getEmail());
            setPassword(member.getPassword());
        }
        

        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return authorityUtils.createAuthorities(this.getEmail()); //(2-3) 리팩토링 포인트
        }

        // (2-4)
        @Override
        public String getUsername() {
            return null;
        }

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

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

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

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

기존에는 loadUserByUsername() 메서드의 리턴값으로 new User(findMember.getEmail(), findMember.getPassword(), authorities);를 리턴했지만 개선된 코드에서는 (1)과 같이 new HelloUserDetails(findMember); 라는 Custom UserDetails 클래스의 생성자로 findMember를 전달하면서 코드가 조금 더 깔끔해졌다.

그리고 기존의 loadUserByUsername() 메서드 내부에서 User 권한 정보를 생성하는 Collection<? extends GrantedAuthority> authorities = authorityUtils.createAuthorities(findMember); 코드가 사라졌다. 이 코드는 (2)에서 정의한 HelloUserDetails 클래스 내부로 포함되었다.

(2)의 HelloUserDetails 클래스는 UserDetails 인터페이스를 구현하고 있고, 또한 Member 엔티티 클래스를 상속하고 있다.

이렇게 구성하면 데이터베이스에서 조회한 회원 정보를 Spring Security의 User 정보롤 변환하는 과정과 User의 권한 정보를 생성하는 과정을 캡슐화할 수 있다.

또한, HelloUserDetails 클래스는 Member 엔티티 클래스를 상속하고 있으므로 HelloUserDetails를 리턴받아 사용하는 측에서는 두 개의 클래스의 객체를 다 손쉽게 캐스팅해서 사용 가능하다는 장점이 있다.

(2-3)에서는 HelloAuthorityUtils의 createAuthorities()메서드를 이용해 User의 권한 정보를 생성하고 있다.

이 코드는 기존에서 loadUserByUsername() 메서드 내부에 있었지만 지금은 HelloUserDetails 클래스 내부에서 사용되도록 캡슐화되었다.

(2-4)에서는 Spring Security에서 인식할 수 있는 username을 Member 클래스의 email 주소로 채우고 있다. getUsername()의 리턴값은 null일 수 없다. User의 식별자는 무조건 있어야 하므로!

지금까지의 코드는 User의 권한 정보를 데이터베이스에서 관리하는 것이 아니라, 데이터베이스에 조회한 User 정보를 기준으로 코드 상에서 조건에 맞게 생성하고 있다.

User의 권한 정보를 DB에서 관리하기 위한 과정은 다음과 같다.

User의 권한 정보를 저장하기 위한 테이블 생성
회원 가입 시, User의 권한 정보(Role)를 데이터베이스에 저장하는 작업
로그인 인증 시, User의 권한 정보를 데이터베이스에서 조회하는 작업

우선, User의 권한 정보 테이블부터 생성해보자.

User의 권한 정보 테이블을 생성하기 전에 User와 User의 권한 정보 간에 관계를 먼저 생각해보자.

package com.codestates.member;

import com.codestates.audit.Auditable;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@NoArgsConstructor
@Getter
@Setter
@Entity
public class Member extends Auditable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long memberId;

    @Column(length = 100, nullable = false)
    private String fullName;

    @Column(nullable = false, updatable = false, unique = true)
    private String email;

    @Column(length = 100, nullable = false)
    private String password;

    @Enumerated(value = EnumType.STRING)
    @Column(length = 20, nullable = false)
    private MemberStatus memberStatus = MemberStatus.MEMBER_ACTIVE;

    //(1) User의 권한 정보 테이블과 매핑되는 정보
    @ElementCollection(fetch = FetchType.EAGER)
    private List<String> roles = new ArrayList<>();

    public Member(String email) {
        this.email = email;
    }

    public Member(String email, String fullName, String password) {
        this.email = email;
        this.fullName = fullName;
        this.password = password;
    }

    public enum MemberStatus {
        MEMBER_ACTIVE("활동중"),
        MEMBER_SLEEP("휴면 상태"),
        MEMBER_QUIT("탈퇴 상태");

        @Getter
        private String status;

        MemberStatus(String status) {
           this.status = status;
        }
    }

    public enum MemberRole {
        ROLE_USER,
        ROLE_ADMIN
    }
}

Member 엔티티 클래스와 User 권한 정보를 매핑하는 것은 (1)과 같이 간단하게 처리할 수 있다.

(1)과 같이 List, Set과 같은 컬렉션 타입의 필드는 @ElementCollection 애너테이션을 추가하여 User 권한 정보와 관련된 별도의 엔티티 클래스를 생성하지 않아도 간단하게 매핑 처리가 된다.

즉, 이 상태에서 애플리케이션을 실행하면 다음과 같은 테이블이 생성된다.

Member 엔티티 클래스와 연관 관계 매핑에 대한 테이블이 생성된다.

한 명의 회원이 한 개 이상의 Role을 가질 수 있으므로, MEMBER 테이블과 MEMBER_ROLES 테이블은 1 대 N 관계이다.

회원 가입을 통해 회원 정보가 MEMBER 테이블에 저장될 때, MEMBER_ROLES 테이블의 MEMBER_MEMBER_ID 열에는 MEMBER 테이블의 기본키 값이 그리고 ROLES 열에는 권한 정보가 저장된다.

회원 가입 시 User의 권한 정보를 데이터베이스에 저장해보자.

package com.codestates.member;

import com.codestates.auth.utils.HelloAuthorityUtils;
import com.codestates.exception.BusinessLogicException;
import com.codestates.exception.ExceptionCode;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

@Transactional
public class DBMemberService implements MemberService {
    ...
    ...
  
    private final HelloAuthorityUtils authorityUtils;

    ...
    ...

    public Member createMember(Member member) {
        verifyExistsEmail(member.getEmail());
        String encryptedPassword = passwordEncoder.encode(member.getPassword());
        member.setPassword(encryptedPassword);

        // (1) Role을 DB에 저장
        List<String> roles = authorityUtils.createRoles(member.getEmail());
        member.setRoles(roles);

        Member savedMember = memberRepository.save(member);

        return savedMember;
    }

    ...
    ...
}

DBMemberService에서 회원 등록 시, 회원의 권한 정보를 데이터베이스에 저장하는 코드가 추가된다.

(1)에서는 authorityUtils.createRoles(member.getEmail());를 통해 회원의 권한 정보(List<String> roles)를 생성한 뒤 member 객체에게 넘겨주고 있다.

아래의 코드는 createRoles() 메서드가 추가된 HelloAuthorityUtils 클래스의 코드이다.

package com.codestates.auth.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
public class HelloAuthorityUtils {
    @Value("${mail.address.admin}")
    private String adminMailAddress;

    ...
    ...

    private final List<String> ADMIN_ROLES_STRING = List.of("ADMIN", "USER");
    private final List<String> USER_ROLES_STRING = List.of("USER");

    ...
    ...

    // (1) DB 저장용
    public List<String> createRoles(String email) {
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES_STRING;
        }
        return USER_ROLES_STRING;
    }
}

(1)에서는 파라미터로 전달된 이메일 주소가 application.yml 파일의 mail.address.admin 프로퍼티에 정의된 이메일 주소와 동일하면 관리자 Role 목록(ADMIN_ROLES_STRING)을 리턴하고, 그 외에는 일반 사용자 Role 목록(USER_ROLES_STRING)을 리턴한다.

로그인 인증 시, User의 권한 정보를 데이터베이스에서 조회하는 방법은 다음과 같다.

package com.codestates.auth;

import com.codestates.auth.utils.HelloAuthorityUtils;
import com.codestates.exception.BusinessLogicException;
import com.codestates.exception.ExceptionCode;
import com.codestates.member.Member;
import com.codestates.member.MemberRepository;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Optional;

@Component
public class HelloUserDetailsServiceV3 implements UserDetailsService {
    private final MemberRepository memberRepository;
    private final HelloAuthorityUtils authorityUtils;

    public HelloUserDetailsServiceV3(MemberRepository memberRepository, HelloAuthorityUtils authorityUtils) {
        this.memberRepository = memberRepository;
        this.authorityUtils = authorityUtils;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<Member> optionalMember = memberRepository.findByEmail(username);
        Member findMember = optionalMember.orElseThrow(() -> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));

        return new HelloUserDetails(findMember);
    }

    private final class HelloUserDetails extends Member implements UserDetails {
        HelloUserDetails(Member member) {
            setMemberId(member.getMemberId());
            setFullName(member.getFullName());
            setEmail(member.getEmail());
            setPassword(member.getPassword());
            setRoles(member.getRoles());        // (1)
        }

        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            // (2) DB에 저장된 Role 정보로 User 권한 목록 생성
            return authorityUtils.createAuthorities(this.getRoles());
        }

        ...
        ...
    }

}

데이터베이스의 MEMBER_ROLES 테이블에서 조회한 Role을 기반으로 User 권한 목록(List<GrantedAuthority>)을 생성하는 로직이 추가된 HelloUserDetailsService 클래스.

먼저 (1)에서는 HelloUserDetails가 상속하고 있는 Member(extends Member)에 데이터베이스에서 조회한 List<String> roles를 전달한다.

그리고 (2)에서 다시 Member(extends Member)에 전달한 Role 정보를 authorityUtils.createAuthorities() 메서드의 파라미터로 전달해서 권한 목록(List<GrantedAuthority>을 생성한다.

데이터베이스에서 Role 정보를 가지고 오지 않았을 때에는 authorityUtils.createAuthorities(this.getEmail()); 이었음.

이제 데이터베이스에서 조회한 Role 정보를 기반으로 User 권한 목록을 생성하는 createAuthorities(List<String> roles) 메서드가 추가된 HelloAuthorityUtils를 보자

package com.codestates.auth.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
public class HelloAuthorityUtils {
    @Value("${mail.address.admin}")
    private String adminMailAddress;

    private final List<GrantedAuthority> ADMIN_ROLES = AuthorityUtils.createAuthorityList("ROLE_ADMIN", "ROLE_USER");
    private final List<GrantedAuthority> USER_ROLES = AuthorityUtils.createAuthorityList("ROLE_USER");
    private final List<String> ADMIN_ROLES_STRING = List.of("ADMIN", "USER");
    private final List<String> USER_ROLES_STRING = List.of("USER");

    // 메모리 상의 Role을 기반으로 권한 정보 생성.
    public List<GrantedAuthority> createAuthorities(String email) {
        if (email.equals(adminMailAddress)) {
            return ADMIN_ROLES;
        }
        return USER_ROLES;
    }

    // (1) DB에 저장된 Role을 기반으로 권한 정보 생성
    public List<GrantedAuthority> createAuthorities(List<String> roles) {
       List<GrantedAuthority> authorities = roles.stream()
               .map(role -> new SimpleGrantedAuthority("ROLE_" + role)) // (2)
               .collect(Collectors.toList());
       return authorities;
    }

    ...
    ...
}

(1)을 보면 기존에는 application.yml 파일의 mail.address.admin 프로퍼티에 정의된 관리자 이메일 주소를 기준으로 관리자 Role을 추가하였으나 이제는 그럴 필요가 없다.

단순히 데이터베이스에서 가지고 온 Role 목록(List<String> roles)을 그대로 사용해서 권한 목록을 만들면 되기 때문에

주의해야 할 것은 (2)와 같이 SimpleGrantedAuthority 객체를 생성할 때 생성자 파라미터로 넘겨주는 값이 "USER" 또는 "ADMIN"으로 넘겨주면 안되고 "ROLE_USER", "ROLE_ADMIN" 형태로 넘겨주어야 한다는 것.

Custom AuthenticationProvider를 사용하는 방법

앞에서 Custom UserDetailsService를 이용해 로그인 인증을 하는 방식은 Spring Security가 내부적으로 인증을 대신 처리해 주는 방식이다.

이번에는 Custom AuthenticationProvider를 이용해 우리가 직접 로그인 인증을 처리하는 방법을 살펴보자.

Custom AuthenticationProvider를 이해하는 데 도움이 되고, 또안 보안 요구 사항에 부합하는 적절한 인증 방식 예를 들어 (2 Factor 인증 등)을 직접 구현해야 할 경우, Custom AuthenticationProvider가 필요할 수 있다.

package com.codestates.auth;

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Optional;

@Component
public class HelloUserAuthenticationProvider implements AuthenticationProvider {   // (1)
    private final HelloUserDetailsService userDetailsService;
    private final PasswordEncoder passwordEncoder;

    public HelloUserAuthenticationProvider(HelloUserDetailsService userDetailsService, 
                                           PasswordEncoder passwordEncoder) {
        this.userDetailsService = userDetailsService;
        this.passwordEncoder = passwordEncoder;
    }


    // (3)
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        UsernamePasswordAuthenticationToken authToken = (UsernamePasswordAuthenticationToken) authentication;  // (3-1)

        // (3-2)
        String username = authToken.getName();
        Optional.ofNullable(username).orElseThrow(() -> new UsernameNotFoundException("Invalid User name or User Password"));

        // (3-3)
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);

        String password = userDetails.getPassword();
        verifyCredentials(authToken.getCredentials(), password);    // (3-4)

        Collection<? extends GrantedAuthority> authorities = userDetails.getAuthorities();  // (3-5)

        // (3-6)
        return UsernamePasswordAuthenticationToken.authenticated(username, password, authorities);
    }

    // (2) HelloUserAuthenticationProvider가 Username/Password 방식의 인증을 지원한다는 것을 Spring Security에 알려준다.
    @Override
    public boolean supports(Class<?> authentication) {
        return UsernamePasswordAuthenticationToken.class.equals(authentication);
    }

    private void verifyCredentials(Object credentials, String password) {
        if (!passwordEncoder.matches((String)credentials, password)) {
            throw new BadCredentialsException("Invalid User name or User Password");
        }
    }
}

(1)과 같이 AuthenticationProvide의 구현 클래스로써 HelloUserAuthenticationProvider를 구현해야 한다.

Spring Security는 위 코드와 같이 AuthentictionProvider를 구현한 클래스가 Spring Bean으로 등록되어 있다면 해당 AuthenticationProvider를 이용해서 인증을 진행한다.

AuthenticationProvider 인터페이스의 구현 클래스는 authenticate(Authentication authentication) 메서드와 supports(Class<?> authentication) 메서드를 구현해야 한다.

그 중 (2)의 supports(Class<?> authentication) 메서드는 우리가 구현하는 Custom AuthenticationProvider(HelloUserAthenticationProvider)가 Username/Password 방식의 인증을 지원한다는 것을 Spring Security한테 알려주는 역할을 한다.

supports() 의 값이 true인 경우, Spring Security는 해당 AuthenticationProvider의 authenticate() 메서드를 호출하여 인증을 진행한다.

(3)의 authenticate(Authentication authentication)에서 우리가 직접 작성한 인증 처리 로직을 이용해 사용자의 인증 여부를 결정한다.

(3-1)에서 authentication을 캐스팅하여 UsernamePasswordAuthenticationToken을 얻는다.

이 UsernamePasswordAuthenticationToken 객체에서 (3-2)와 같이 해당 사용자의 Username을 얻은 후, 존재하는지 체크한다.

Username이 존재하면 (3-3)과 같이 userDetailsService를 이용해 데이터베이스에서 해당 사용자를 조회한다.

(3-4)에서 로그인 정보에 포함된 패스워드(authToken.getCredentials())와 데이터베이스에 저장된 사용자의 패스워드 정보와 일치하는지를 검증한다.

(3-4)의 인증 과정을 통과했다면 로그인 인증에 성공한 사용자이므로 (3-5)와 같이 해당 사용자의 권한을 생성한다.

마지막으로 (3-6)과 같이 인증된 사용자의 인증 정보를 리턴값으로 전달한다. 이 인증 정보는 내부적으로 Spring Security에서 관리하게 된다.

*SecurityConfiguration의 .loginProcessingUrl("/process_login")에서 "/process_login"에 대한 요청이 들어오면 HelloUserAuthenticationProvider가 동작하여 로그인 인증을 처리하게 되고, 만약 Custom AuthenticationProvider를 작성하지 않으면 내부적으로 AuthenticationProvider를 호출하여 인증 처리를 하고, 기본적으로 제공되는 DaoAuthenticationProvider를 사용하게 된다.

이제 애플리케이션을 다시 실행하고, 회원 가입을 한 뒤, 로그인을 해보자.

회원 가입 시 등록한 이메일 주소/패스워드를 올바르게 입력하면 정상적으로 Hello, Spring Security의 메인 화면이 브라우저에 표시된다.

만약 회원 가입을 하지 않고 로그인을 할 경우 인증에 실패하고, 다음과 같은 하얀 에러 화면을 만나게 된다.

우리가 앞에서 HelloUserDetailsService를 통해 인증을 처리할 경우에는 인증 실패 시, Spring Security 내부에서 인증 실패에 대한 전용 Exception인 AuthenticationException을 throw하게 되고, 이 AuthenticationException이 throw 되면 결과적으로 SecurityCofiguration에서 설정한 .failureUrl("auths/login-form?error")를 통해 로그인 폼으로 리다이렉트하면서 아래와 같이 "로그인 인증에 실패했습니다."라는 인증 실패 페이지를 표시한다.

그런데 Custom AuthenticationProvider를 사용할 경우, 회원 가입 전 인증 실패 시, 왜 그림과 같은 화면이 아닌 "Whitelebel Error Page" 가 표시되는 것일까?

이유는 MemberService에서 등록된 회원 정보가 없으면, BusinessLogicException을 throw 하는데 이때 BusinessLogicException이 Custom AuthenticationProvider를 거쳐서 그대로 Spring Security 내부 영역으로 throw되기 때문이다.

Spring Security에서는 인증 실패 시, authenticationException이 throw되지 않으면 Exception에 대한 별도의 처리를 하지 않고, 서블릿 컨테이너의 톰캣 쪽으로 처리를 넘긴다.

결국 서블릿 컨테이너 영역에서 해당 Exception에 대한 "/error" URL로 포워딩하는데 우리가 특별히 "/error" URL로 포워딩되었을 때 보여줄 뷰 페이지를 별도로 구성하지 않기 때문에 디폴트 페이지인 "Whitelebel Error Page"를 브라우저에 표시하는 것.

⭐️ 해결책은 간단함. Custom AuthenticationProvider에서 Exception이 발생할 경우, 이 Exception을 catch해서 AuthenticationException으로 rethrow를 해주면 된다.

package com.codestates.auth;

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Optional;

@Component
public class HelloUserAuthenticationProvider implements AuthenticationProvider {
    private final HelloUserDetailsService userDetailsService;
    private final PasswordEncoder passwordEncoder;

    public HelloUserAuthenticationProvider(HelloUserDetailsService userDetailsService,
                                           PasswordEncoder passwordEncoder) {
        this.userDetailsService = userDetailsService;
        this.passwordEncoder = passwordEncoder;
    }

    // V2: AuthenticationException을 rethrow 하는 개선 코드
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        UsernamePasswordAuthenticationToken authToken = (UsernamePasswordAuthenticationToken) authentication;

        String username = authToken.getName();
        Optional.ofNullable(username).orElseThrow(() -> new UsernameNotFoundException("Invalid User name or User Password"));
        try {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            String password = userDetails.getPassword();
            verifyCredentials(authToken.getCredentials(), password);

            Collection<? extends GrantedAuthority> authorities = userDetails.getAuthorities();
            return UsernamePasswordAuthenticationToken.authenticated(username, password, authorities);
        } catch (Exception ex) {
            throw new UsernameNotFoundException(ex.getMessage()); // (1) AuthenticationException으로 다시 throw 한다.
        }
    }

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

    private void verifyCredentials(Object credentials, String password) {
        if (!passwordEncoder.matches((String)credentials, password)) {
            throw new BadCredentialsException("Invalid User name or User Password");
        }
    }
}

(1)에서 UsernameNotFoundException을 throw 하도록 수정되었는데, UsernameNotFoundException을 throw하도록 수정되었는데, UsernameNoFoundException은 AuthenticationException을 상속하는 하위 Exception이기 때문에 이 UsernameNotFoundException이 throw하게 되면 Spring Security쪽에서 정상적으로 catch해서 정상적인 인증 실패 화면으로 리다이렉트 시켜준다.

⭐ Custom AuthenticationProvider에서 AuthenticationException이 아닌 Exception이 발생할 경우에는 꼭 AuthenticationException을 rethrow 하도록 코드를 구성해야 한다

*AuthenticationProvider는 Spring Security에서 클라이언트로부터 전달받은 인증 정보를 바탕으로 인증된 사용자인지에 대한 인증 처리를 수행하는 Spring Security 컴포넌트이다. AuthenticationProvider는 인터페이스 형태.

다음 포스팅을 통해 Srpgin Security에서 내부적으로 일어나는 User 인증과 권한에 대한 처리 과정을 구체적으로 알아보도록 하자.

'Spring🌸' 카테고리의 다른 글

Spring Security - JWT를 이용한 자격 증명 및 검증 구현 (0)	2023.06.07
Spring Security - JWT 자격 증명을 위한 로그인 인증 구현 (0)	2023.06.07
Spring Security - JWT 인증(Authentication) (0)	2023.05.17
Spring MVC - JUnit을 사용한 단위 테스트 (0)	2023.04.30
Spring MVC - JDBC 기반 데이터 액세스 계층 (0)	2023.04.18

현재글Spring Security - 기본

nothing_is_in_my_way

기록의 즐거움...😉

jwt #토큰기반인증, Spring Data JDBC, 메소드 오버로딩 #오버라이딩 #객체 #OOP, C# #ASP.NET 강의 추천, 예외처리 공통화 #RestControllerAdvice #ExceptionHandle, KPT #어느새4월..., JWT #로그인 인증 #자격증명, DI #Spring Core, IOC #DI #AOP #PSA #POJO #SpringBoot #Spring #Framework #Library, JVM #RuntimeDataArea #GC #GarbageCollection, Stream #stream #스트림 #람다 #람다식 #lambda #annotation, 조인 #Innerjoin #OuterJoin, Spring Container #Component, Java 재귀 #재귀함수 #피보나치 #팩토리얼, XSS #CSRF #쿠키 #세션 #보안공격, JPA #엔티티 테이블 매핑 #영속성 컨텍스트 #PC, 동전교환문제 #거스름돈 문제 #DP, sql #ddl #dml #dcl #tcl, Spring Security 기본 #Authentication #Authorization, Spring프로젝트인식안될 때,

Today :
Yesterday :

nothing_is_in_my_way

Spring Security - 기본

'Spring🌸' 카테고리의 다른 글

'Spring🌸'의 다른글

티스토리툴바

« 2025/05 »
일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

Spring Security - 기본

'Spring🌸' 카테고리의 다른 글

'Spring🌸'의 다른글

관련글

티스토리툴바