스프링 시큐리티로 웹 애플리케이션 보안 구현 🛡️

안녕하세요, 여러분! 오늘은 정말 흥미진진한 주제로 여러분과 함께 시간을 보내려고 해요. 바로 스프링 시큐리티를 이용한 웹 애플리케이션 보안 구현에 대해 알아볼 거예요. 🎉

여러분, 혹시 집 문을 열어둔 채로 외출한 적 있나요? 아마 그런 일은 없었을 거예요. 왜냐고요? 당연히 우리의 소중한 집과 재산을 지키기 위해서죠! 웹 애플리케이션도 마찬가지예요. 우리가 만든 소중한 웹 애플리케이션을 안전하게 지키는 것, 정말 중요하죠?

그래서 오늘은 여러분의 웹 애플리케이션을 든든하게 지켜줄 스프링 시큐리티에 대해 자세히 알아보려고 해요. 마치 슈퍼히어로가 도시를 지키듯, 스프링 시큐리티가 여러분의 애플리케이션을 지켜줄 거예요! 🦸‍♂️

자, 그럼 이제 스프링 시큐리티의 세계로 함께 떠나볼까요? 준비되셨나요? Let's go! 🚀

1. 스프링 시큐리티란? 🤔

자, 여러분! 스프링 시큐리티가 뭔지 궁금하시죠? 간단히 말해서, 스프링 시큐리티는 스프링 기반 애플리케이션의 보안(인증과 권한, 인가 등)을 담당하는 스프링 하위 프레임워크예요. 우와, 뭔가 어려워 보이죠? 걱정 마세요. 차근차근 설명해 드릴게요!

🔑 핵심 포인트: 스프링 시큐리티는 애플리케이션의 보안을 쉽고 효과적으로 구현할 수 있게 도와주는 도구예요.

스프링 시큐리티를 사용하면, 마치 경비원이 건물을 지키는 것처럼 여러분의 웹 애플리케이션을 안전하게 보호할 수 있어요. 누가 들어올 수 있고, 누가 들어올 수 없는지, 들어온 사람은 어디까지 갈 수 있는지 등을 꼼꼼하게 관리해주는 거죠.

예를 들어, 재능넷과 같은 재능 공유 플랫폼을 운영한다고 생각해볼까요? 이런 사이트에서는 사용자의 개인정보, 결제 정보, 재능 정보 등 중요한 데이터가 많이 있겠죠? 이런 데이터를 안전하게 보호하는 것이 정말 중요해요. 스프링 시큐리티는 이런 중요한 데이터를 지키는 데 큰 도움을 줄 수 있답니다.

1.1 스프링 시큐리티의 주요 기능 🛠️

스프링 시큐리티는 정말 다양한 기능을 제공해요. 마치 만능 도구상자 같죠? 어떤 기능들이 있는지 한번 살펴볼까요?

✅ 인증 (Authentication): 사용자가 누구인지 확인해요. 로그인할 때 아이디와 비밀번호를 확인하는 것과 같아요.
✅ 인가 (Authorization): 인증된 사용자가 어떤 일을 할 수 있는지 권한을 관리해요.
✅ 암호화: 중요한 정보를 안전하게 보관하기 위해 암호화해요.
✅ CSRF 공격 방지: 악의적인 요청을 막아줘요.
✅ 세션 관리: 사용자의 로그인 상태를 유지하고 관리해요.

와우! 정말 많은 기능이 있죠? 이 모든 기능을 우리가 직접 구현하려면 정말 힘들 거예요. 하지만 스프링 시큐리티를 사용하면 이 모든 것을 쉽게 구현할 수 있답니다. 마치 레고 블록을 조립하듯이 말이에요! 🧱

1.2 스프링 시큐리티의 동작 원리 🔄

자, 이제 스프링 시큐리티가 어떻게 동작하는지 알아볼까요? 조금 복잡해 보일 수 있지만, 천천히 따라오세요. 재미있을 거예요!

위의 그림을 보세요. 스프링 시큐리티의 동작 원리를 간단하게 표현해봤어요. 어떤가요? 이해가 조금 되시나요?

사용자 요청: 모든 것은 사용자의 요청으로 시작돼요. 예를 들어, 로그인 버튼을 클릭하는 것처럼요.
필터 체인: 사용자의 요청은 여러 개의 필터를 거쳐요. 각 필터는 요청을 검사하고 필요한 작업을 수행해요.
인증/인가: 사용자가 누구인지, 어떤 권한이 있는지 확인해요.
리소스 접근: 모든 검사를 통과하면 요청한 리소스에 접근할 수 있어요.

이렇게 스프링 시큐리티는 여러 단계를 거쳐 우리의 애플리케이션을 안전하게 지켜주는 거예요. 마치 성 주변의 해자, 성벽, 경비병들이 차례로 적을 막아내는 것처럼 말이죠! 🏰

💡 재미있는 사실: 스프링 시큐리티의 필터 체인은 마치 러시아 전통 인형 '마트료시카'와 비슷해요. 하나의 필터 안에 또 다른 필터가 있고, 그 안에 또 다른 필터가 있는 식이죠!

자, 이제 스프링 시큐리티가 무엇인지, 어떻게 동작하는지 기본적인 이해가 되셨나요? 정말 멋지고 강력한 도구죠? 이제 우리의 웹 애플리케이션을 어떻게 지킬 수 있는지 더 자세히 알아볼까요? 다음 섹션에서 계속됩니다! 🚀

2. 스프링 시큐리티 설정하기 🛠️

자, 이제 본격적으로 스프링 시큐리티를 우리의 프로젝트에 적용해볼 거예요. 마치 집에 첨단 보안 시스템을 설치하는 것처럼 말이죠! 😎

2.1 의존성 추가하기 📦

스프링 시큐리티를 사용하기 위해서는 먼저 프로젝트에 필요한 의존성을 추가해야 해요. Maven을 사용한다면 pom.xml 파일에, Gradle을 사용한다면 build.gradle 파일에 다음과 같이 추가해주세요.

Maven (pom.xml):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradle (build.gradle):

implementation 'org.springframework.boot:spring-boot-starter-security'

이렇게 의존성을 추가하면, 스프링 부트가 자동으로 기본적인 보안 설정을 해줘요. 마치 집에 기본 잠금장치를 설치하는 것과 같죠! 🔒

2.2 기본 설정 클래스 만들기 🏗️

기본 설정만으로는 부족하죠? 우리만의 특별한 보안 설정을 추가해볼까요? 이를 위해 설정 클래스를 만들어야 해요.

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.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
        return http.build();
    }
}

우와! 뭔가 복잡해 보이죠? 걱정 마세요. 하나씩 설명해 드릴게요. 😊

@Configuration: 이 클래스가 설정 클래스임을 스프링에게 알려줘요.
@EnableWebSecurity: 웹 보안을 활성화한다고 스프링에게 말해주는 거예요.
SecurityFilterChain: 이 메서드에서 실제로 보안 설정을 정의해요.

이 설정은 다음과 같은 의미를 가져요:

홈페이지("/")와 "/home" 페이지는 모든 사람이 접근할 수 있어요. (마치 집의 현관문 같죠?)
다른 모든 페이지는 인증된 사용자만 접근할 수 있어요. (집 안의 다른 방들처럼요)
로그인 페이지는 "/login"이고, 모든 사람이 접근할 수 있어요. (현관 벨을 누를 수 있는 것처럼요)
로그아웃 기능도 제공해요. (집에서 나갈 때 문을 잠그는 것과 같아요)

🔑 핵심 포인트: 이 설정으로 우리 웹사이트의 기본적인 보안 구조가 만들어져요. 누가 어디에 접근할 수 있는지, 어떻게 로그인하고 로그아웃할 수 있는지를 정의하는 거죠.

2.3 사용자 정보 설정하기 👤

보안 시스템을 설치했으니, 이제 누가 들어올 수 있는지 정해야겠죠? 스프링 시큐리티에서는 이를 '사용자 정보 설정'이라고 해요.

간단한 예제로, 메모리에 사용자 정보를 저장하는 방법을 살펴볼게요. (실제 프로젝트에서는 데이터베이스를 사용하는 것이 좋아요!)

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.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
public class UserConfig {

    @Bean
    public UserDetailsService users() {
        UserDetails user = User.builder()
            .username("user")
            .password("{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW")
            .roles("USER")
            .build();
        UserDetails admin = User.builder()
            .username("admin")
            .password("{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW")
            .roles("USER", "ADMIN")
            .build();
        return new InMemoryUserDetailsManager(user, admin);
    }
}

이 설정은 두 명의 사용자를 만들어요:

'user'라는 이름의 일반 사용자
'admin'이라는 이름의 관리자

두 사용자 모두 비밀번호는 'password'예요. (실제 프로젝트에서는 더 강력한 비밀번호를 사용해야 해요!)

⚠️ 주의: 이 예제에서는 비밀번호를 BCrypt로 암호화했어요. 실제 비밀번호를 코드에 직접 작성하는 것은 매우 위험해요! 프로덕션 환경에서는 절대 이렇게 하면 안 됩니다.

자, 이제 기본적인 스프링 시큐리티 설정이 완료됐어요! 🎉 우리의 웹 애플리케이션은 이제 기본적인 보안 기능을 갖추게 됐답니다. 재능넷과 같은 플랫폼을 운영한다면, 이런 기본적인 보안 설정만으로도 사용자들의 정보를 한층 더 안전하게 보호할 수 있어요.

하지만 우리의 여정은 여기서 끝나지 않아요. 더 강력하고 세밀한 보안을 위해 계속해서 나아가볼까요? 다음 섹션에서는 더 심화된 스프링 시큐리티 기능들을 살펴볼 거예요. 준비되셨나요? Let's go! 🚀

3. 인증(Authentication) 구현하기 🔐

자, 이제 우리 웹 애플리케이션의 문을 어떻게 열고 닫을지 정했으니, 실제로 사용자를 어떻게 인증할지 알아볼 차례예요. 인증이란 쉽게 말해 "너 누구야?"라고 물어보는 과정이에요. 😊

3.1 폼 로그인 구현하기 📝

가장 기본적인 인증 방식은 폼 로그인이에요. 사용자가 아이디와 비밀번호를 입력하면, 우리가 확인하고 입장을 허가하는 거죠. 마치 파티장 입구에서 초대장을 확인하는 것과 같아요!

앞서 만든 SecurityConfig 클래스를 조금 수정해볼게요:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home", "/signup").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
        return http.build();
    }
}

이 설정은 다음과 같은 의미를 가져요:

"/", "/home", "/signup" 페이지는 모든 사람이 접근 가능해요. (파티장 로비같은 곳이죠)
나머지 페이지는 인증된 사용자만 접근할 수 있어요. (VIP룸 같은 곳!)
로그인 페이지는 "/login"이에요. (파티장 입구라고 생각하면 돼요)
로그아웃도 가능해요. (파티장을 떠나는 것과 같죠)

이제 로그인 페이지를 만들어볼까요? login.html이라는 이름으로 다음과 같이 만들어주세요:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org">
    <head>
        <title>Please Log In</title>
    </head>
    <body>
        <h1>Please Log In</h1>
        <div th:if="${param.error}">
            Invalid username and password.
        </div>
        <div th:if="${param.logout}">
            You have been logged out.
        </div>
        <form th:action="@{/login}" method="post">
            <div>
                <input type="text" name="username" placeholder="Username"/>
            </div>
            <div>
                <input type="password" name="password" placeholder="Password"/>
            </div>
            <input type="submit" value="Log in" />
        </form>
    </body>
</html>

와우! 이제 우리만의 멋진 로그인 페이지가 생겼어요. 🎨 이 페이지는 사용자 이름과 비밀번호를 입력받고, 로그인 시도 시 스프링 시큐리티가 자동으로 처리해줘요.

🔑 핵심 포인트: 스프링 시큐리티는 기본적으로 /login 경로로 POST 요청이 오면 인증을 시도해요. 우리가 만든 폼이 정확히 이 조건을 만족하므로, 별도의 컨트롤러 없이도 로그인 처리가 가능해요!

3.2 커스텀 인증 구현하기 🛠️

때로는 기본 인증 방식으로는 부족할 때가 있어요. 예를 들어, 재능넷에서 이메일로 로그인하고 싶다면 어떻게 해야 할까요? 이럴 때 커스텀 인증이 필요해요!

먼저, UserDetailsService를 구현해볼게요:

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(email)
            .orElseThrow(() -> new UsernameNotFoundException("User not found with email: " + email));

        return org.springframework.security.core.userdetails.User
            .withUsername(user.getEmail())
            .password(user.getPassword())
            .roles(user.getRoles().toArray(new String[0]))
            .build();
    }
}

좋아요! 계속해서 커스텀 인증 구현에 대해 알아보겠습니다. 🚀

이제 우리가 만든 CustomUserDetailsService를 스프링 시큐리티 설정에 적용해볼까요?

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home", "/signup").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
        return http.build();
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

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

이렇게 하면 우리가 만든 커스텀 사용자 서비스를 스프링 시큐리티가 사용하게 됩니다. 이제 이메일로 로그인할 수 있게 되었어요! 🎉

3.3 소셜 로그인 구현하기 🌐

요즘에는 소셜 미디어 계정으로 로그인하는 것이 트렌드죠. 재능넷에서도 이런 기능을 제공하면 어떨까요? 구글 로그인을 예로 들어볼게요.

먼저, 의존성을 추가해야 해요:

implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'

그리고 application.yml 파일에 구글 OAuth2 설정을 추가해주세요:

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_GOOGLE_CLIENT_ID
            client-secret: YOUR_GOOGLE_CLIENT_SECRET

이제 SecurityConfig 클래스를 수정해볼까요?

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home", "/signup").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .oauth2Login()
                .loginPage("/login")
                .and()
            .logout()
                .permitAll();
        return http.build();
    }

    // ... 기존 코드 ...
}

와우! 이제 구글 로그인도 지원하게 되었어요. 사용자들이 더 쉽게 재능넷에 접근할 수 있게 되었죠. 😊

🔑 핵심 포인트: 소셜 로그인을 추가하면 사용자 경험이 크게 향상됩니다. 하지만 보안에 더욱 신경 써야 해요. 항상 최신 버전의 라이브러리를 사용하고, 보안 업데이트를 주기적으로 확인하세요!

3.4 다중 인증 방식 구현하기 🔀

때로는 하나의 애플리케이션에서 여러 가지 인증 방식을 지원해야 할 때가 있어요. 예를 들어, 재능넷에서 일반 사용자는 폼 로그인을, API를 사용하는 클라이언트는 토큰 기반 인증을 사용하고 싶다면 어떻게 해야 할까요?

이럴 때는 다중 인증 방식을 구현할 수 있어요. 예를 들어보겠습니다:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home", "/signup").permitAll()
                .antMatchers("/api/**").authenticated()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .oauth2Login()
                .loginPage("/login")
                .and()
            .httpBasic()  // API 인증을 위한 Basic Auth 추가
                .and()
            .logout()
                .permitAll();
        return http.build();
    }

    // ... 기존 코드 ...
}

이렇게 설정하면, 웹 페이지에서는 폼 로그인과 소셜 로그인을 사용하고, API 호출 시에는 Basic Auth를 사용할 수 있어요. 정말 다재다능하죠? 😎

⚠️ 주의: Basic Auth는 보안상 취약할 수 있어요. 실제 프로덕션 환경에서는 JWT나 OAuth2와 같은 더 안전한 인증 방식을 사용하는 것이 좋습니다.

자, 이제 우리는 다양한 인증 방식을 구현해봤어요. 폼 로그인, 소셜 로그인, 그리고 API를 위한 Basic Auth까지! 재능넷의 사용자들은 이제 더욱 편리하고 안전하게 서비스를 이용할 수 있게 되었어요. 🎊

다음 섹션에서는 인가(Authorization)에 대해 알아볼 거예요. 인증된 사용자가 어떤 작업을 할 수 있는지 제어하는 방법에 대해 배워볼까요? 준비되셨나요? Let's go! 🚀

4. 인가(Authorization) 구현하기 🚦

자, 이제 사용자가 누구인지 알았으니 (인증), 그 사용자가 무엇을 할 수 있는지 정해볼 차례예요 (인가). 이것은 마치 놀이공원에서 키 제한이 있는 놀이기구와 같아요. 모든 사람이 공원에 들어올 순 있지만 (인증), 특정 놀이기구는 키가 커야 탈 수 있죠 (인가). 😊

4.1 역할 기반 접근 제어 (Role-Based Access Control, RBAC) 구현하기 👥

RBAC는 사용자의 역할에 따라 접근 권한을 부여하는 방식이에요. 재능넷에서 일반 사용자, 멘토, 관리자 역할을 만들어볼까요?

먼저, SecurityConfig 클래스를 수정해볼게요:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home", "/signup").permitAll()
                .antMatchers("/user/**").hasRole("USER")
                .antMatchers("/mentor/**").hasRole("MENTOR")
                .antMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
        return http.build();
    }

    // ... 기존 코드 ...
}

이 설정은 다음과 같은 의미를 가져요:

"/user/**" 경로는 USER 역할을 가진 사용자만 접근 가능해요.
"/mentor/**" 경로는 MENTOR 역할을 가진 사용자만 접근 가능해요.
"/admin/**" 경로는 ADMIN 역할을 가진 사용자만 접근 가능해요.

이제 사용자 엔티티에 역할 정보를 추가해볼까요?

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;
    private String password;

    @ElementCollection(fetch = FetchType.EAGER)
    private List<String> roles = new ArrayList<>();

    // getters and setters
}

이렇게 하면 각 사용자마다 여러 역할을 가질 수 있어요. 예를 들어, 어떤 사용자는 USER이면서 동시에 MENTOR일 수 있죠!

4.2 메서드 수준 보안 구현하기 🔒

때로는 특정 메서드에 대해서만 보안을 적용하고 싶을 때가 있어요. 이럴 때 메서드 수준 보안을 사용할 수 있어요. 예를 들어볼까요?

먼저, @EnableGlobalMethodSecurity 어노테이션을 SecurityConfig 클래스에 추가해주세요:

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
    // ... 기존 코드 ...
}

이제 서비스 클래스에서 다음과 같이 메서드 수준 보안을 적용할 수 있어요:

@Service
public class TalentService {

    @PreAuthorize("hasRole('MENTOR')")
    public void createTalentClass(TalentClass talentClass) {
        // 재능 클래스 생성 로직
    }

    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        // 사용자 삭제 로직
    }

    @PostAuthorize("returnObject.createdBy == authentication.name")
    public TalentClass getTalentClass(Long classId) {
        // 재능 클래스 조회 로직
    }
}

이 예제에서:

createTalentClass 메서드는 MENTOR 역할을 가진 사용자만 호출할 수 있어요.
deleteUser 메서드는 ADMIN 역할을 가진 사용자만 호출할 수 있어요.
getTalentClass 메서드는 누구나 호출할 수 있지만, 반환된 객체의 createdBy 필드가 현재 인증된 사용자의 이름과 일치해야 해요.

🔑 핵심 포인트: 메서드 수준 보안은 비즈니스 로직에 직접 보안을 적용할 수 있어 매우 강력해요. 하지만 남용하면 코드가 복잡해질 수 있으니 적절히 사용해야 해요!

4.3 동적 권한 부여 구현하기 🔄

때로는 더 복잡한 권한 로직이 필요할 수 있어요. 예를 들어, 재능넷에서 재능 클래스의 소유자나 관리자만 해당 클래스를 수정할 수 있게 하고 싶다면 어떻게 해야 할까요?

이럴 때 PermissionEvaluator를 구현할 수 있어요:

@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {

    @Autowired
    private TalentClassRepository talentClassRepository;

    @Override
    public boolean hasPermission(Authentication auth, Object targetDomainObject, Object permission) {
        if ((auth == null) || (targetDomainObject == null) || !(permission instanceof String)) {
            return false;
        }
        String permissionString = (String) permission;

        if (targetDomainObject instanceof TalentClass) {
            return hasPermissionForTalentClass(auth, (TalentClass) targetDomainObject, permissionString);
        }
        return false;
    }

    private boolean hasPermissionForTalentClass(Authentication auth, TalentClass talentClass, String permission) {
        if (permission.equals("edit")) {
            return talentClass.getCreatedBy().equals(auth.getName()) || auth.getAuthorities().stream()
                    .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
        }
        return false;
    }

    @Override
    public boolean hasPermission(Authentication auth, Serializable targetId, String targetType, Object permission) {
        if ((auth == null) || (targetId == null) || !(permission instanceof String)) {
            return false;
        }
        String permissionString = (String) permission;

        if (targetType.equals("TalentClass")) {
            TalentClass talentClass = talentClassRepository.findById((Long) targetId).orElse(null);
            if (talentClass != null) {
                return hasPermissionForTalentClass(auth, talentClass, permissionString);
            }
        }
        return false;
    }
}

이제 이 CustomPermissionEvaluator를 스프링 시큐리티 설정에 등록해주세요:

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomPermissionEvaluator customPermissionEvaluator;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // ... 기존 설정 ...
            .and()
            .exceptionHandling().accessDeniedHandler(accessDeniedHandler());
    }

    @Bean
    public MethodSecurityExpressionHandler methodSecurityExpressionHandler() {
        DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(customPermissionEvaluator);
        return expressionHandler;
    }

    // ... 기존 코드 ...
}

이제 다음과 같이 메서드 수준에서 동적 권한 검사를 할 수 있어요:

@Service
public class TalentClassService {

    @PreAuthorize("hasPermission(#classId, 'TalentClass', 'edit')")
    public void updateTalentClass(Long classId, TalentClassDTO updatedClass) {
        // 재능 클래스 업데이트 로직
    }
}

이렇게 하면 재능 클래스의 소유자나 관리자만 해당 클래스를 수정할 수 있게 됩니다. 정말 멋지죠? 😎

⚠️ 주의: 동적 권한 부여는 매우 강력하지만, 복잡한 로직은 성능에 영향을 줄 수 있어요. 꼭 필요한 경우에만 사용하고, 가능한 한 간단하게 유지하세요!

자, 이제 우리는 재능넷에 아주 강력하고 유연한 보안 시스템을 구축했어요! 사용자 역할에 따른 접근 제어, 메서드 수준의 보안, 그리고 동적 권한 부여까지! 이제 사용자들은 안전하게 자신의 재능을 공유하고 배울 수 있게 되었어요. 🎉

다음 섹션에서는 이 모든 보안 기능을 테스트하는 방법에 대해 알아볼 거예요. 준비되셨나요? Let's go! 🚀

5. 보안 테스트하기 🧪

우리가 구현한 보안 기능이 제대로 작동하는지 확인하는 것은 정말 중요해요. 마치 새로 지은 집의 문과 창문이 제대로 잠기는지 확인하는 것과 같죠. 자, 이제 우리의 재능넷 보안 시스템을 테스트해볼까요? 🕵️‍♀️

5.1 단위 테스트 작성하기 🧩

먼저, 개별 컴포넌트들이 제대로 작동하는지 확인하는 단위 테스트를 작성해볼게요. 예를 들어, CustomUserDetailsService를 테스트해볼까요?

@RunWith(MockitoJUnitRunner.class)
public class CustomUserDetailsServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private CustomUserDetailsService userDetailsService;

    @Test
    public void whenValidUsername_thenUserShouldBeFound() {
        // Given
        String email = "test@example.com";
        User user = new User(email, "password", Arrays.asList("ROLE_USER"));
        when(userRepository.findByEmail(email)).thenReturn(Optional.of(user));

        // When
        UserDetails foundUser = userDetailsService.loadUserByUsername(email);

        // Then
        assertNotNull(foundUser);
        assertEquals(email, foundUser.getUsername());
        assertTrue(foundUser.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_USER")));
    }

    @Test(expected = UsernameNotFoundException.class)
    public void whenInvalidUsername_thenThrowException() {
        // Given
        String email = "invalid@example.com";
        when(userRepository.findByEmail(email)).thenReturn(Optional.empty());

        // When
        userDetailsService.loadUserByUsername(email);

        // Then
        // Exception is expected
    }
}

이 테스트는 CustomUserDetailsService가 유효한 이메일로 사용자를 찾을 수 있는지, 그리고 유효하지 않은 이메일에 대해 적절한 예외를 던지는지 확인해요.

5.2 통합 테스트 작성하기 🔗

단위 테스트만으로는 부족해요. 여러 컴포넌트가 함께 잘 작동하는지 확인하는 통합 테스트도 필요하죠. 예를 들어, 인증과 인가가 제대로 작동하는지 테스트해볼까요?

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class SecurityIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void whenAccessProtectedEndpoint_thenRedirectToLogin() throws Exception {
        mockMvc.perform(get("/user/profile"))
                .andExpect(status().is3xxRedirection())
                .andExpect(redirectedUrl("http://localhost/login"));
    }

    @Test
    @WithMockUser(roles = "USER")
    public void whenUserAccessUserEndpoint_thenOk() throws Exception {
        mockMvc.perform(get("/user/profile"))
                .andExpect(status().isOk());
    }

    @Test
    @WithMockUser(roles = "USER")
    public void whenUserAccessAdminEndpoint_thenForbidden() throws Exception {
        mockMvc.perform(get("/admin/dashboard"))
                .andExpect(status().isForbidden());
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    public void whenAdminAccessAdminEndpoint_thenOk() throws Exception {
        mockMvc.perform(get("/admin/dashboard"))
                .andExpect(status().isOk());
    }
}

이 테스트들은 다음을 확인해요:

보호된 엔드포인트에 접근하면 로그인 페이지로 리다이렉트되는지
USER 역할을 가진 사용자가 /user/** 엔드포인트에 접근할 수 있는지
USER 역할을 가진 사용자가 /admin/** 엔드포인트에 접근할 수 없는지
ADMIN 역할을 가진 사용자가 /admin/** 엔드포인트에 접근할 수 있는지

5.3 보안 취약점 스캔하기 🔍

마지막으로, 우리 애플리케이션에 알려진 보안 취약점이 없는지 확인해볼까요? 이를 위해 OWASP Dependency-Check와 같은 도구를 사용할 수 있어요.

Gradle을 사용한다면, 다음과 같이 설정할 수 있어요:

plugins {
    id 'org.owasp.dependencycheck' version '6.2.2'
}

dependencyCheck {
    failBuildOnCVSS = 7
    formats = ['HTML', 'JSON']
}

이제 ./gradlew dependencyCheckAnalyze 명령을 실행하면, 프로젝트의 의존성들을 스캔하고 알려진 취약점이 있는지 확인해줘요.

🔑 핵심 포인트: 보안 테스트는 한 번으로 끝나는 게 아니에요. 새로운 기능을 추가하거나 의존성을 업데이트할 때마다 반복적으로 수행해야 해요!

와우! 이제 우리는 재능넷의 보안을 철저히 테스트했어요. 단위 테스트로 개별 컴포넌트를, 통합 테스트로 전체 시스템을, 그리고 취약점 스캔으로 알려진 보안 문제들을 확인했죠. 이제 사용자들은 더욱 안전하게 재능을 공유하고 배울 수 있을 거예요! 🎉

물론이죠! 계속해서 스프링 시큐리티와 재능넷의 보안에 대해 더 자세히 알아보겠습니다. 🚀

6. 고급 보안 기능 구현하기 🔐

지금까지 우리는 기본적인 인증과 인가 기능을 구현했어요. 하지만 재능넷과 같은 플랫폼은 더 강력한 보안이 필요할 수 있어요. 이제 몇 가지 고급 보안 기능을 추가해볼까요?

6.1 다중 요소 인증(MFA) 구현하기 🔢

다중 요소 인증은 사용자의 계정을 더욱 안전하게 보호할 수 있어요. 예를 들어, 비밀번호 외에 SMS로 전송된 코드를 입력하게 할 수 있죠.

Spring Security에서 MFA를 구현하기 위해 AuthenticationProvider를 커스터마이즈해볼게요:

@Component
public class MfaAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    private SmsService smsService;

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String username = authentication.getName();
        String password = authentication.getCredentials().toString();

        UserDetails user = userDetailsService.loadUserByUsername(username);

        if (passwordEncoder.matches(password, user.getPassword())) {
            // 첫 번째 인증 성공, SMS 코드 전송
            String smsCode = smsService.sendVerificationCode(user.getPhone());
            
            // SMS 코드 검증을 위한 토큰 반환
            return new MfaAuthenticationToken(user, password, user.getAuthorities(), smsCode);
        }

        throw new BadCredentialsException("Invalid username or password");
    }

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

이제 SMS 코드를 검증하는 필터를 추가해야 해요:

public class MfaAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        
        if (auth instanceof MfaAuthenticationToken && !((MfaAuthenticationToken) auth).isAuthenticated()) {
            String smsCode = request.getParameter("smsCode");
            if (smsCode != null && smsCode.equals(((MfaAuthenticationToken) auth).getSmsCode())) {
                // SMS 코드 검증 성공, 완전한 인증 부여
                SecurityContextHolder.getContext().setAuthentication(
                    new UsernamePasswordAuthenticationToken(auth.getPrincipal(), auth.getCredentials(), auth.getAuthorities())
                );
            }
        }
        
        filterChain.doFilter(request, response);
    }
}

이렇게 하면 사용자는 비밀번호 입력 후 SMS로 받은 코드를 추가로 입력해야 완전한 인증이 이루어져요. 보안이 한층 강화되었죠! 🛡️

6.2 OAuth2를 이용한 소셜 로그인 확장하기 🌐

앞서 우리는 구글 로그인을 구현했어요. 하지만 재능넷 사용자들은 다른 소셜 미디어로도 로그인하고 싶어할 수 있어요. Facebook과 GitHub 로그인을 추가해볼까요?

application.yml 파일에 다음 설정을 추가해주세요:

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_GOOGLE_CLIENT_ID
            client-secret: YOUR_GOOGLE_CLIENT_SECRET
          facebook:
            client-id: YOUR_FACEBOOK_CLIENT_ID
            client-secret: YOUR_FACEBOOK_CLIENT_SECRET
          github:
            client-id: YOUR_GITHUB_CLIENT_ID
            client-secret: YOUR_GITHUB_CLIENT_SECRET

그리고 SecurityConfig 클래스를 다음과 같이 수정해주세요:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // ... 기존 설정 ...
            .oauth2Login()
                .loginPage("/login")
                .userInfoEndpoint()
                    .userService(customOAuth2UserService);
    }

    @Autowired
    private CustomOAuth2UserService customOAuth2UserService;
}

이제 사용자들은 구글, 페이스북, 깃허브 계정으로 재능넷에 로그인할 수 있어요. 정말 편리해졌죠? 😊

6.3 CSRF 보호 강화하기 🛡️

스프링 시큐리티는 기본적으로 CSRF 보호 기능을 제공하지만, 우리는 이를 더욱 강화할 수 있어요. 예를 들어, CSRF 토큰을 쿠키에 저장하는 방식을 사용해볼 수 있죠.

SecurityConfig 클래스에 다음 설정을 추가해주세요:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // ... 기존 설정 ...
            .csrf()
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
    }
}

이렇게 하면 CSRF 토큰이 쿠키에 저장되고, JavaScript로 읽을 수 있게 돼요. 이는 SPA(Single Page Application)에서 특히 유용해요.

🔑 핵심 포인트: CSRF 보호는 중요하지만, REST API에서는 불필요할 수 있어요. API 키나 토큰을 사용하는 경우, CSRF 보호를 비활성화하는 것이 좋을 수 있습니다.

6.4 보안 헤더 추가하기 📋

마지막으로, 몇 가지 보안 헤더를 추가해 재능넷의 보안을 더욱 강화해볼까요?

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // ... 기존 설정 ...
            .headers()
                .contentSecurityPolicy("script-src 'self' https://trustedscripts.example.com; object-src 'none'; report-uri /csp-report-endpoint/")
                .and()
                .referrerPolicy(ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN)
                .and()
                .featurePolicy("geolocation 'none'")
                .and()
                .frameOptions().deny()
                .and()
                .httpStrictTransportSecurity().includeSubDomains(true).maxAgeInSeconds(31536000);
    }
}

이 설정은 다음과 같은 보안 헤더를 추가해요: