authenticate() 메서드는 인증 개체를 수신하고 반환합니다. authenticate() 메서드 내부에 사용자 지정 인증 로직을 모두 구현할 수 있습니다.

AuthenticationProvider 인터페이스의 두 번째 방법은 지원(Class<?> Authentication)입니다. 현재 AuthenticationProvider가 제공된 Authentication 개체의 유형을 지원하는 경우 true를 반환하도록 이 방법을 구현합니다.

CORS (Cross-Origin Resource Sharing, 교차 출처 리소스 공유) CORS는 웹 리소스가 다른 도메인의 리소스에 접근할 수 있도록 허용하는 메커니즘이다. 예를 들어, 도메인 A에서 도메인 B의 API를 호출하려면 CORS 정책을 설정해야 할 수 있다.

CSRF (Cross-Site Request Forgery, 사이트 간 요청 위조) CSRF는 공격자가 사용자의 세션을 이용해 악의적인 작업을 수행하는 공격 방법입니다. 사용자가 로그인한 상태에서 공격자가 준비한 페이지를 열면, 그 페이지에서는 사용자의 권한으로 서버에 요청을 보낼 수 있습니다.

프론트 단 (유튜버가 미리 만들어 둠)

https://github.com/eazybytes/springsecurity6/tree/3.1.2/section6/bank-app-ui

필요한 테이블 쿼리

https://github.com/eazybytes/springsecurity6/blob/3.1.2/section6/springsecsection6/src/main/resources/sql/scripts.sql

계정 저장

CORS 에러

CORS 란

CORS는 브라우저 클라이언트에서 실행되는 스크립트가 다른 원본의 리소스와 상호 작용할 수 있도록 하는 프로토콜입니다. 예를 들어 UI 앱이 다른 도메인에서 실행 중인 API 호출을 원할 경우 CORS로 인해 기본적으로 차단됩니다. 대부분의 브라우저에서 도입한 WsC의 사양입니다.

따라서 CORS는 보안 문제/공격이 아니라 서로 다른 원본 간의 데이터/통신 공유를 중단하기 위해 브라우저가 제공하는 기본 보호 기능입니다.

CORS 다루기

서버에 배치된 웹 APP UI가 다른 서버에 배치된 REST 서비스와 통신을 시도하는 유효한 시나리오가 있다면 @CrossOrigin 주석을 사용하여 이러한 종류의 통신을 허용할 수 있습니다. @CrossOrigin을 사용하면 모든 도메인의 클라이언트가 API를 사용할 수 있습니다.

해결책

웹 앱 내의 모든 컨트롤러에 @CrossOrigin 주석을 언급하는 대신 아래와 같은 Spring Security를 사용하여 CORS 관련 구성을 전역적으로 정의할 수 있습니다.

코드

import java.util.Collections;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;

import jakarta.servlet.http.HttpServletRequest;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        // http://localhost:4200 에 대한 CORS 허용
        http.cors(corsCustomizer -> corsCustomizer.configurationSource(new CorsConfigurationSource() {
            @Override
            public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
                CorsConfiguration config = new CorsConfiguration();
                config.setAllowedOrigins(Collections.singletonList("http://localhost:4200"));
                config.setAllowedMethods(Collections.singletonList("*"));
                config.setAllowCredentials(true);
                config.setAllowedHeaders(Collections.singletonList("*"));
                config.setMaxAge(3600L);
                return config;
            }
        }))
        // csrf 비활성화 (사이트 요청 위조) ---> csrf 토큰이 없어도 서버는 응답
        // 스프링에서는 csrf 기본은 활성화 (보안 목적) ---> csrf 토큰을 url에 포함해야 서버는 응답
        .csrf((csrf) -> csrf.disable()) 
                .authorizeHttpRequests((requests)->requests
                        .requestMatchers("/myAccount","/myBalance","/myLoans","/myCards", "/user").authenticated()
                        .requestMatchers("/notices","/contact","/register").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();
    }

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


}

성공

crsf 비활성화 시, (주석 처리)

status: 401 Unauthorized 확인

Cross-site Request Forgery (CSRF): 사이트 간 요청 위조

일반적으로 CSRF 또는 XSRF(Cross-Site Request Fuggement) 공격은 사용자의 명시적인 동의 없이 웹 어플리케이션에서 동작을 수행하는 것을 목적으로 하며, 일반적으로 사용자의 압흔을 직접적으로 훔치는 것이 아니라 사용자를 이용하여 자신의 의지 없이 동작을 수행하는 것을 목적으로 합니다.

netflix.com 웹사이트와 공격자의 웹사이트 evil.com 를 사용하고 있다고 생각합니다

1단계 : Netfilx.com 에 대한 넷플릭스 사용자 로그인과 넷플릭스의 백엔드 서버는 Netflix.com 도메인 이름에 대해 브라우저에 저장할 쿠키를 제공합니다

--->사용자가 자격 증명을 제출하고 Netflix.com 에 로그인합니다

<---넷플릭스 서버는 Netflix.com 도메인 이름을 기반으로 쿠키를 만들고 사용자 브라우저에 저장합니다.

2단계 : 같은 넷플릭스 사용자가 브라우저의 다른 탭에서 evil.com 웹사이트를 엽니다.

--->사용자가 evil.com 에 호스팅된 악의적인 블로그/사이트에 액세스했습니다

<---evil.com 은 넷플릭스 계정의 이메일을 변경하기 위한 악성 링크가 내장된 웹 페이지를 반환합니다. 그러나 링크는 아이폰에서 "90%" OFF와 같은 텍스트로 나타납니다.

3단계 : 사용자가 Netflix.com 에 요청하는 악성 링크를 유혹하여 클릭하였고, 동일한 브라우저에 이미 존재하는 로그인 쿠키와 동일한 도메인 Netflix.com 에 이메일 변경 요청이 이루어지므로 Netflix.com 의 백엔드 서버는 요청이 온 곳을 구별할 수 없습니다. 따라서 여기서 evil.com 은 Netflix.com UI 페이지에서 오는 것처럼 요청을 위조하였습니다.

--->사용자는 아래와 같은 내용이 있는 evil.com 의 링크를 클릭합니다

<---쾅!! 넷플릭스 계정 이메일이 바뀌었네요.

CSRF 공격에 대한 솔루션

CSRF 공격을 물리치기 위해서는 응용 프로그램의 사용자 인터페이스를 통해 HTTP 요청이 합법적으로 생성되었는지 여부를 판단할 수 있는 방법이 필요합니다. 이를 달성하기 위한 가장 좋은 방법은 CSRF 토큰을 통해서입니다.

CSRF 토큰은 CSRF 공격을 방지하기 위해 사용되는 안전한 랜덤 토큰입니다. 토큰은 사용자 세션마다 고유해야 하며 추측하기 어렵도록 큰 랜덤 값이어야 합니다.

이것이 어떻게 CSRF 공격을 해결하는지 이전 넷플릭스의 예를 다시 들어보겠습니다.

1단계 : Netflix.com 에 대한 넷플릭스 사용자 로그인과 넷플릭스의 백엔드 서버는 이 특정 사용자 세션에 대해 무작위로 생성된 고유 CSRF 토큰과 함께 도메인 이름 Netflix.com 에 대해 브라우저에 저장할 쿠키를 제공합니다. CSRF 토큰은 세션 쿠키에 노출되지 않도록 HTML 양식의 숨겨진 매개변수 내에 삽입됩니다.

2단계 : 같은 넷플릭스 사용자가 브라우저의 다른 탭에서 evil.com 웹사이트를 엽니다.

3단계 : 사용자가 Netflix.com 에 요청하는 악성 링크를 유혹하여 클릭하였습니다. 그리고 동일한 브라우저에 이미 존재하는 로그인 쿠키와 이메일 변경 요청이 Netflix.com 에 이루어졌기 때문에 이번에는 Netflix.com 백엔드 서버가 쿠키와 함께 CSRF 토큰을 기대합니다. CSRF 토큰은 로그인 작업 중에 생성된 초기 값과 동일해야 합니다.

CSRF 토큰은 애플리케이션 서버가 최종 사용 요청이 동일한 App UI에서 오는지 여부를 확인하는 데 사용됩니다. 애플리케이션 서버는 CSRF 토큰이 테스트와 일치하지 않으면 요청을 거부합니다.

Disable CSRF PROTECTION (CSRF 보호 비활성화)

기본적으로 Spring Security는 웹 애플리케이션에 구현된 CSRF 솔루션이 없는 경우 오류 403으로 모든 HTTP POST, PUT, DELETE, PATCH 작업을 차단합니다. Spring Security에서 제공하는 CSRF 보호를 비활성화하여 이 기본 동작을 변경할 수 있습니다.

✅ 추가 해야 하는 코드!!!

// 핸들러는 CSRF 토큰을 요청 속성(attribute)으로 설정하는 역할
CsrfTokenRequestAttributeHandler requestHandler = new CsrfTokenRequestAttributeHandler();

// CSRF 토큰의 이름을 "_csrf"로 설정. 즉, 요청이 들어올 때 "_csrf"라는 이름의 요청 속성(attribute)에 CSRF 토큰 값이 저장
requestHandler.setCsrfRequestAttributeName("_csrf");

// CSRF 활성화 (조건)
.csrf((csrf) -> csrf.csrfTokenRequestHandler(requestHandler)                            // CSRF 토큰을 요청 핸들러에 설정
                    .ignoringRequestMatchers("/contact", "/register")                    // 특정 URL 경로(/contact, /register)에 대해서는 CSRF 검증을 무시하도록 설정
                    .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))// CSRF 토큰을 어떻게 저장할지 설정하는 부분 (쿠키를 사용하며, HttpOnly 속성을 false로 설정 ->  JavaScript에서 쿠키에 접근)

전체 코드
package com.example.springsecurity65.config;

import java.util.Collections;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.security.web.csrf.CsrfTokenRequestAttributeHandler;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;

import jakarta.servlet.http.HttpServletRequest;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        // 핸들러는 CSRF 토큰을 요청 속성(attribute)으로 설정하는 역할
        CsrfTokenRequestAttributeHandler requestHandler = new CsrfTokenRequestAttributeHandler();

        // CSRF 토큰의 이름을 "_csrf"로 설정. 즉, 요청이 들어올 때 "_csrf"라는 이름의 요청 속성(attribute)에 CSRF 토큰 값이 저장
        requestHandler.setCsrfRequestAttributeName("_csrf");

        // http://localhost:4200 에 대한 CORS 허용
        http.cors(corsCustomizer -> corsCustomizer.configurationSource(new CorsConfigurationSource() {
            @Override
            public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
                CorsConfiguration config = new CorsConfiguration();
                config.setAllowedOrigins(Collections.singletonList("http://localhost:4200"));
                config.setAllowedMethods(Collections.singletonList("*"));
                config.setAllowCredentials(true);
                config.setAllowedHeaders(Collections.singletonList("*"));
                config.setMaxAge(3600L);
                return config;
            }
        }))
        // csrf 비활성화 (사이트 요청 위조) ---> csrf 토큰이 없어도 서버는 응답
        // 스프링에서는 csrf 기본은 활성화 (보안 목적) ---> csrf 토큰을 url에 포함해야 서버는 응답 
        //.csrf((csrf) -> csrf.disable()) ---> CSRF 비활성화 

        // CSRF 활성화 (조건)
        .csrf((csrf) -> csrf.csrfTokenRequestHandler(requestHandler)                            // CSRF 토큰을 요청 핸들러에 설정
                            .ignoringRequestMatchers("/contact", "/register")                    // 특정 URL 경로(/contact, /register)에 대해서는 CSRF 검증을 무시하도록 설정
                            .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))// CSRF 토큰을 어떻게 저장할지 설정하는 부분 (쿠키를 사용하며, HttpOnly 속성을 false로 설정 ->  JavaScript에서 쿠키에 접근) 


                .authorizeHttpRequests((requests)->requests
                        .requestMatchers("/myAccount","/myBalance","/myLoans","/myCards", "/user").authenticated()
                        .requestMatchers("/notices","/contact","/register").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();
    }

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


}

결과

"/regist", "/contact" 에 대한 접근 성공

클라이언트에게 CSRF 토큰 안전하게 전달

일반적으로 CSRF 토큰은 클라이언트와 서버 간의 요청에서 보안을 강화하기 위해 사용됩니다. 이 필터를 통해 서버는 응답 헤더에 CSRF 토큰 정보를 담아 클라이언트에게 전달하게 됩니다. 클라이언트는 이 토큰을 사용하여 이후의 요청에서 서버로 보내면, 서버는 이 토큰을 검증하여 요청이 유효한지 판단하게 됩니다.

✅ 코드 추가 !!!

✅✅✅
http.securityContext((context) -> context
                .requireExplicitSave(false))
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.ALWAYS))


// CSRF 활성화 (조건)
.csrf((csrf) -> csrf.csrfTokenRequestHandler(requestHandler)                            // CSRF 토큰을 요청 핸들러에 설정
                    .ignoringRequestMatchers("/contact", "/register")                    // 특정 URL 경로(/contact, /register)에 대해서는 CSRF 검증을 무시하도록 설정
                    .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))// CSRF 토큰을 어떻게 저장할지 설정하는 부분 (쿠키를 사용하며, HttpOnly 속성을 false로 설정 ->  JavaScript에서 쿠키에 접근) 

                ✅✅✅ // CsrfCookieFilter 필터( 이 필터는 요청마다 한 번씩 실행되는 OncePerRequestFilter를 상속받아 구현) 추가 (Basic 인증이 처리된 후에 이 필터가 실행)
                .addFilterAfter(new CsrfCookieFilter(), BasicAuthenticationFilter.class)

전체 코드
package com.example.springsecurity65.config;

import java.util.Collections;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.security.web.csrf.CsrfTokenRequestAttributeHandler;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;

import com.example.springsecurity65.filter.CsrfCookieFilter;

import jakarta.servlet.http.HttpServletRequest;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        // 핸들러는 CSRF 토큰을 요청 속성(attribute)으로 설정하는 역할
        CsrfTokenRequestAttributeHandler requestHandler = new CsrfTokenRequestAttributeHandler();

        // CSRF 토큰의 이름을 "_csrf"로 설정. 즉, 요청이 들어올 때 "_csrf"라는 이름의 요청 속성(attribute)에 CSRF 토큰 값이 저장
        requestHandler.setCsrfRequestAttributeName("_csrf");

        // requireExplicitSave(false)는 보안 컨텍스트가 명시적으로 저장되어야 하는지 여부를 설정
        http.securityContext((context) -> context

                // false로 설정하면, 명시적으로 저장하지 않아도 됨.
                .requireExplicitSave(false))

                // sessionCreationPolicy(SessionCreationPolicy.ALWAYS)는 항상 새로운 세션을 생성하도록 설정합니다. 
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.ALWAYS))

            // http://localhost:4200 에 대한 CORS 허용
            .cors(corsCustomizer -> corsCustomizer.configurationSource(new CorsConfigurationSource() {
            @Override
            public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
                CorsConfiguration config = new CorsConfiguration();
                config.setAllowedOrigins(Collections.singletonList("http://localhost:4200"));
                config.setAllowedMethods(Collections.singletonList("*"));
                config.setAllowCredentials(true);
                config.setAllowedHeaders(Collections.singletonList("*"));
                config.setMaxAge(3600L);
                return config;
            }
        }))
        // csrf 비활성화 (사이트 요청 위조) ---> csrf 토큰이 없어도 서버는 응답
        // 스프링에서는 csrf 기본은 활성화 (보안 목적) ---> csrf 토큰을 url에 포함해야 서버는 응답 
        //.csrf((csrf) -> csrf.disable()) ---> CSRF 비활성화 

        // CSRF 활성화 (조건)
        .csrf((csrf) -> csrf.csrfTokenRequestHandler(requestHandler)                            // CSRF 토큰을 요청 핸들러에 설정
                            .ignoringRequestMatchers("/contact", "/register")                    // 특정 URL 경로(/contact, /register)에 대해서는 CSRF 검증을 무시하도록 설정
                            .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))// CSRF 토큰을 어떻게 저장할지 설정하는 부분 (쿠키를 사용하며, HttpOnly 속성을 false로 설정 ->  JavaScript에서 쿠키에 접근) 

                            // CsrfCookieFilter 필터( 이 필터는 요청마다 한 번씩 실행되는 OncePerRequestFilter를 상속받아 구현) 추가 (Basic 인증이 처리된 후에 이 필터가 실행)
                            .addFilterAfter(new CsrfCookieFilter(), BasicAuthenticationFilter.class)

                .authorizeHttpRequests((requests)->requests
                        .requestMatchers("/myAccount","/myBalance","/myLoans","/myCards", "/user").authenticated()
                        .requestMatchers("/notices","/contact","/register").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();
    }

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


}

sessionCreationPolicy(SessionCreationPolicy.ALWAYS)는 항상 새로운 세션을 생성하도록 설정합니다. 이 설정은 다음과 같은 경우에 유용할 수 있습니다:

1.사용자가 로그인할 때마다 새로운 세션을 생성하려는 경우 2.사용자가 애플리케이션에 접근할 때마다 세션 정보를 새로 생성하려는 경우 기본적으로, Spring Security는 필요할 때만 세션을 생성합니다. 하지만 이 설정을 ALWAYS로 하면, 요청이 들어올 때마다 새로운 세션을 생성하게 됩니다. 이것은 특별한 요구 사항이 있을 때 유용하게 사용될 수 있습니다.

클래스 생성(CsrfCookieFilter)

package com.example.springsecurity65.filter;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.web.csrf.CsrfToken;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

public class CsrfCookieFilter extends OncePerRequestFilter {

    // doFilterInternal 메서드를 오버라이드하여 실제 필터의 로직을 구현
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        // CsrfToken 클래스의 인스턴스를 요청 속성에서 가져오기 (현재 요청에 대한 CSRF 토큰 정보를 가져오기)
        CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName());

        // 응답 헤더에 CSRF 토큰을 설정
        if(null != csrfToken.getHeaderName()){
            // CSRF 토큰의 이름(헤더 이름)과 값을 응답 헤더에 설정 -> 클라이언트 측에서 이 헤더를 읽어 CSRF 토큰을 알 수 있게 됨.
            response.setHeader(csrfToken.getHeaderName(), csrfToken.getToken());
        }

        // 다음 필터로 요청과 응답을 전달
        filterChain.doFilter(request, response);
    }

}

🟢 [인코딩 (Encoding)] 인코딩은 데이터를 한 형태에서 다른 형태로 변환하는 과정으로 정의되며, 암호학과는 관련이 없습니다.

이 과정은 비밀이 없으며 완전히 되돌릴 수 있습니다.

인코딩은 데이터를 보호하는 데 사용될 수 없습니다. 다음은 인코딩에 사용되는 다양한 공개적으로 사용 가능한 알고리즘입니다.

예: ASCII, BASE64, UNICODE

🟢 [암호화 (Encryption)] 암호화는 기밀성을 보장하는 방식으로 데이터를 변환하는 과정으로 정의됩니다.

기밀성을 달성하기 위해, 암호화는 암호학 용어로 "키"라고 부르는 방식을 사용해야 합니다.

"키"의 도움으로 복호화를 사용하면 암호화를 되돌릴 수 있습니다. "키"가 기밀인 한, 암호화는 안전한 것으로 간주될 수 있습니다.

🟢 [해싱 (Hashing)] 해싱에서는 해싱 함수를 사용하여 데이터를 해시 값으로 변환합니다.

한 번 해싱된 데이터는 되돌릴 수 없습니다. 생성된 해시 값에서 원래 데이터를 알 수 없습니다.

임의의 데이터와 해싱 알고리즘의 출력이 주어지면 원래 입력 데이터와 일치하는지 확인할 수 있으며 원래 데이터를 볼 필요가 없습니다.

노출 되도 상관없는 데이터 -> 인코딩 (ex. 카테고리) DB에서 꺼낸 뒤 다시 볼 데이터 -> 암호화 (ex. 핸드폰, 이메일) 다시 볼 필요 없고, 확인만 필요한 데이터 -> 해싱 (비밀번호)

암호화 프로세스

해싱된 비밀번호를 DB에서 가져온 뒤, 맞는지만 확인.

PasswordEncoder 메소드

보통 BCryptPasswordEncoder 많이 사용

encode : 암호화 메소드

mathces: 일치 여부 확인

upgradeEncoding: 더 강력하게 업그레이드 해야 하는지 확인 (시간이 지남에 따라 덜 안전해지는 경우)

upgradeEncoding 예시

@Override
public boolean upgradeEncoding(String encodedPassword) {
    // Check the encoding algorithm used for the password
    // Return true if an upgrade is needed, false otherwise
    return !encodedPassword.startsWith("{bcrypt}");
}

🟣 코드

스프링부트 3.1.2 자바: OpenJDK 17 Gradle: 8.3

🟢 ProjectSecurityConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        // csrf 비활성화 (사이트 요청 위조) ---> csrf 토큰이 없어도 서버는 응답
        // 스프링에서는 csrf 기본은 활성화 (보안 목적) ---> csrf 토큰을 url에 포함해야 서버는 응답
        http.csrf((csrf) -> csrf.disable()) 
                .authorizeHttpRequests((requests)->requests
                        .requestMatchers("/myAccount","/myBalance","/myLoans","/myCards").authenticated()
                        .requestMatchers("/notices","/contact","/register").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();
    }

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


}

🟢 LoginController.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.springsecurity63.model.Customer;
import com.example.springsecurity63.repository.CustomerRepository;

@RestController
public class LoginController {

    @Autowired
    private CustomerRepository customerRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestBody Customer customer) {

        Customer savedCustomer = null;
        ResponseEntity response = null;

        try {
            // encrypt
            String hashPwd = passwordEncoder.encode(customer.getPwd());
            customer.setPwd(hashPwd);

            // save
            savedCustomer = customerRepository.save(customer);

            if (savedCustomer.getId() > 0) {
                response = ResponseEntity
                        .status(HttpStatus.CREATED)
                        .body("Given user details are successfully registered");
            }
        } catch (Exception ex) {
            response = ResponseEntity
                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("An exception occured due to " + ex.getMessage());
        }
        return response;
    }

}

결과

만약 id 2번으로 로그인 시도 시, 자격 증명 실패

소스코드: https://github.com/sorrynthx/Spring-Boot

그 다음에는 Implement and Customize the Authentication Provider에 대해서 작성.

SecurityConfig.java 수정

🟢 csrf (사이트간 요청 위조) 비활성화

csrf 활성화 -> crsf 토큰 필요 (기본) csrf 비활성화 -> crsf 토큰 불필요 (옵션)

** 더 자세한 설명은 여기서 https://junhyunny.github.io/information/security/spring-boot/spring-security/cross-site-reqeust-forgery/

🟣 코드

crsf 비활성화, /register 추가 등록

package com.example.springsecurity62.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        // csrf 비활성화 (사이트 요청 위조) ---> csrf 토큰이 없어도 서버는 응답
        // 스프링에서는 csrf 기본은 활성화 (보안 목적) ---> csrf 토큰을 url에 포함해야 서버는 응답
        http.csrf((csrf) -> csrf.disable()) 
                .authorizeHttpRequests((requests)->requests
                        .requestMatchers("/myAccount","/myBalance","/myLoans","/myCards").authenticated()
                        .requestMatchers("/notices","/contact","/register").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();
    }

     /**
     * NoOpPasswordEncoder is not recommended for production usage.
     * Use only for non-prod.
     *
     * @return PasswordEncoder
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    /*
     * @Bean public UserDetailsService userDetailsService(DataSource dataSource) {
     * return new JdbcUserDetailsManager(dataSource); }
     */

}

로그인 컨트롤러 만들기 (사용자 등록)

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.springsecurity62.model.Customer;
import com.example.springsecurity62.repository.CustomerRepository;

@RestController
public class LoginController {

    @Autowired
    private CustomerRepository customerRepository;

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestBody Customer customer) {
        System.out.println("sssss");
        Customer savedCustomer = null;
        ResponseEntity response = null;
        try {
            savedCustomer = customerRepository.save(customer);
            if (savedCustomer.getId() > 0) {
                response = ResponseEntity
                        .status(HttpStatus.CREATED)
                        .body("Given user details are successfully registered");
            }
        } catch (Exception ex) {
            response = ResponseEntity
                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("An exception occured due to " + ex.getMessage());
        }
        return response;
    }

}

🟢 구조

🟢 테스트

플로우

해석

1. 사용자가 처음으로 보안 페이지에 액세스를 시도합니다. 사용자가 처음으로 보안된 페이지에 접근을 시도하면, 내부적으로 몇 가지 필터가 작동합니다.

2. AuthorizationFilter, DefaultLoginPageGeneratingFilter 등의 필터가 사용자가 로그인하지 않았음을 감지하고 로그인 페이지로 리다이렉트합니다. 이러한 필터들은 사용자가 로그인하지 않았다는 것을 확인하고 로그인 페이지로 사용자를 리다이렉트합니다.

3. 사용자가 자신의 자격 증명을 입력하고, 요청이 필터에 의해 가로채집니다. 사용자가 로그인 정보를 입력하면, 이 요청은 Spring Security 필터에 의해 처리됩니다.

4. UsernamePasswordAuthenticationFilter와 같은 필터는 요청에서 사용자 이름과 비밀번호를 추출하고, Authentication 인터페이스의 구현체인 UsernamePasswordAuthenticationToken 객체를 생성합니다. 그리고 ProviderManager의 authenticate() 메서드를 호출합니다. 해당 필터는 로그인 정보를 추출하고 인증을 위한 객체를 생성하여 인증 과정을 시작합니다.

5. ProviderManager는 AuthenticationManager의 구현체로, 주어진 인증 객체 스타일을 지원하는 사용 가능한 AuthenticationProvider 목록을 식별합니다. 기본적으로 ProviderManager가 DaoAuthenticationProvider의 authenticate() 메서드를 호출합니다. 이 단계에서는 적절한 인증 제공자를 선택하여 인증 과정을 계속 진행합니다.

6. DaoAuthenticationProvider는 EazyBankUserDetails의 loadUserByUsername() 메서드를 호출하여 사용자 세부 정보를 로드합니다. 사용자 세부 정보가 로드되면 기본 비밀번호 인코더 구현을 사용하여 비밀번호를 비교하고 사용자가 정통한지 여부를 검증합니다. 이 단계에서는 사용자의 세부 정보를 로드하고 비밀번호를 검증하여 인증 과정을 완료합니다.

7. 마지막으로 인증 성공 여부와 관련된 Authentication 객체를 ProviderManager에 반환합니다.

8. ProviderManager는 인증이 성공했는지 확인합니다. 그렇지 않으면 다른 사용 가능한 AuthenticationProvider로 시도합니다. 그렇지 않으면 필터에 인증 세부 정보를 반환합니다. 인증의 성공 여부를 확인하고 처리합니다.

9. 인증 객체는 필터에 의해 SecurityContext 객체에 저장되어 향후 사용되고, 응답이 최종 사용자에게 반환됩니다. 인증 정보는 나중에 사용할 수 있도록 저장되며, 응답이 사용자에게 전달됩니다.

플로우

비밀번호 일치 확인

현재는 plain text 으로 비밀번호가 저장.

다음에는 암호화 해서 저장하고 비밀번호가 일치하는지 확인하는 프로세스를 추가 해보자.

❗LdapUserDetailsManager는 회사에서 사용 안하기 때문에 튜토리얼 제외

InMemoryUserDetailsManager (withDefaultPasswordEncoder 방식)

application.properties에 단일 사용자를 정의하는 대신, InMemoryUserDetailsManager를 이용하여 여러 사용자 정의해보기

🟣 코드

package com.example.springsecurity61.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
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.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(
                (requests) -> requests.requestMatchers("/myAccount", "/myBalance", "/myLoans", "/myCards").authenticated()
                                      .requestMatchers("/notices", "/contact").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());

        return http.build();
    }

    @Bean
    public InMemoryUserDetailsManager userDetailsService() {

        // Approach1 passwordEncoder 없이 테스트 (deprecated 뜸)

        UserDetails admin = User.withDefaultPasswordEncoder()
                                .username("admin")
                                .password("123123")
                                .authorities("admin")
                                .build();

        UserDetails user = User.withDefaultPasswordEncoder()
                               .username("user")
                               .password("123123")
                               .authorities("read")
                               .build();

        return new InMemoryUserDetailsManager(admin, user);
    }



}

InMemoryUserDetailsManager (PasswordEncorder 방식)

package com.example.springsecurity61.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
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.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(
                (requests) -> requests.requestMatchers("/myAccount", "/myBalance", "/myLoans", "/myCards").authenticated()
                                      .requestMatchers("/notices", "/contact").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());

        return http.build();
    }

    @Bean
    public InMemoryUserDetailsManager userDetailsService() {

        // Approach 2 NoOpPasswordEncoder Bean 사용
        UserDetails admin = User.withUsername("admin")
                                .password("123132")
                                .authorities("admin")
                                .build();
        UserDetails user = User.withUsername("user")
                                .password("123123")
                                .authorities("read")
                                .build();

        return new InMemoryUserDetailsManager(admin, user);
    }

     /**
     * NoOpPasswordEncoder is not recommended for production usage.
     * Use only for non-prod.
     *
     * @return PasswordEncoder
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

}

User Management (사용자 관리 Interface)

🟢 UserDetailsService (인터페이스)

목적: 특정 사용자의 정보를 로드하는 핵심 인터페이스입니다. 메서드: loadUserByUsername(String username) 설명: 사용자 이름을 기반으로 사용자의 세부 정보를 로드합니다. 일반적으로 인증 과정에서 사용됩니다.

🟢 UserDetailsManager (인터페이스)

목적: UserDetailsService의 확장으로, 새 사용자를 생성하고 기존 사용자를 업데이트하는 기능을 제공합니다. 메서드: createUser(UserDetails user): 새 사용자 생성 updateUser(UserDetails user): 기존 사용자 업데이트 deleteUser(String username): 사용자 삭제 changePassword(String oldPwd, String newPwd): 비밀번호 변경 userExists(String username): 사용자 존재 여부 확인 설명: 사용자 관리 기능을 위한 중요한 인터페이스로, 사용자 생성, 업데이트, 삭제 등의 작업을 수행할 수 있습니다.

🟢 InMemoryUserDetailsManager (클래스) 🟢 JdbcUserDetailsManager (클래스) 🟢 LdapUserDetailsManager (클래스)

목적: Spring Security 팀에서 제공하는 UserDetailsManager의 구현 예제 클래스들입니다. 설명: InMemoryUserDetailsManager: 메모리 내에서 사용자 정보를 관리합니다. 주로 개발 및 테스트에 사용됩니다. JdbcUserDetailsManager: 관계형 데이터베이스를 통해 사용자 정보를 관리합니다. LdapUserDetailsManager: LDAP 데이터베이스를 통해 사용자 정보를 관리합니다.

UserDetails & Authentication 관계 (사용자 세부 정보와 인증)

🟢 Principal (인터페이스) ---> Authentication (인터페이스) ---> UsernamePasswordAuthenticationToken (클래스)

메서드: getName(): 사용자 이름 반환 getPrincipal(): 인증 주체 반환 getAuthorities(): 사용자 권한 반환 getCredentials(): 사용자 자격 증명 반환 getDetails(): 인증 세부 정보 반환 isAuthenticated(): 인증 여부 확인 setAuthenticated(): 인증 상태 설정 eraseCredentials(): 자격 증명 지우기

설명: 인증은 사용자가 자신이 주장하는 사람인지 확인하는 과정입니다. Authentication 인터페이스는 인증 정보를 나타내며, UsernamePasswordAuthenticationToken 클래스는 사용자 이름과 비밀번호를 기반으로 한 인증을 나타냅니다.

사용처: Authentication은 인증이 성공적인지 여부를 판단하는 모든 시나리오에서 반환 타입입니다. 예를 들어, AuthenticationProvider 및 AuthenticationManager 내부에서 사용됩니다.

🟢 UserDetails (인터페이스) ---> User (클래스)

메서드: getPassword(): 비밀번호 반환 getUsername(): 사용자 이름 반환 getAuthorities(): 사용자 권한 반환 isAccountNonExpired(): 계정 만료 여부 확인 isAccountNonLocked(): 계정 잠금 여부 확인 isEnabled(): 계정 활성화 여부 확인 isCredentialsNonExpired(): 자격 증명 만료 여부 확인 eraseCredentials(): 자격 증명 지우기

설명: UserDetails 인터페이스는 사용자의 세부 정보를 나타냅니다. 이 정보는 인증 과정에서 사용되며, User 클래스는 이를 구현한 예제입니다.

사용처: UserDetails는 저장 시스템에서 사용자 정보를 로드하는 모든 시나리오에서 반환 타입입니다. 예를 들어, UserDetailsService 및 UserDetailsManager 내부에서 사용됩니다.

결론 UserDetails와 Authentication은 Spring Security에서 사용자의 세부 정보와 인증 정보를 나타내는 중요한 구성 요소입니다. _UserDetails는 사용자의 세부 정보를 관리_하며, _Authentication은 인증 과정을 담당_합니다. 이 두 요소는 사용자 인증 및 권한 관리의 핵심 역할을 하며, 개발자는 이를 이해하고 적절히 활용해야 합니다.

🟣 코드

-- MYSQL DB를 이용하여 스프링 시큐리티 인증 테스트 

-- test.users definition

CREATE TABLE `users` (
  `id` int DEFAULT NULL,
  `username` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  `enabled` int DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

INSERT INTO test.users (id, username, password, enabled) VALUES(1, 'happy', '12345', 1);

-- test.authorities definition

CREATE TABLE `authorities` (
  `id` int DEFAULT NULL,
  `username` varchar(100) DEFAULT NULL,
  `authority` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

INSERT INTO test.authorities (id, username, authority) VALUES(1, 'happy', 'read');


-- customer  (JPA 설치 + 앱 실행 후)
INSERT INTO `customer` (`email`, `pwd`, `role`)
 VALUES ('johndoe@example.com', '54321', 'admin');

# application.properties

## spring JDBC
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=#testdb123!
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

#build.gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.security:spring-security-test'

    // spring jdbc
    implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
    implementation 'mysql:mysql-connector-java:8.0.26'

    // spring ldap (optional)
      implementation 'org.springframework.boot:spring-boot-starter-data-ldap'

    // JPA
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
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.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.provisioning.JdbcUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(
                (requests) -> requests.requestMatchers("/myAccount", "/myBalance", "/myLoans", "/myCards").authenticated()
                                      .requestMatchers("/notices", "/contact").permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());

        return http.build();
    }

         /**
     * NoOpPasswordEncoder is not recommended for production usage.
     * Use only for non-prod.
     *
     * @return PasswordEncoder
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Bean
    public UserDetailsService userDetailsService(DataSource dataSource) {
        return new JdbcUserDetailsManager(dataSource);
    }

}

package com.example.springsecurity61.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.hibernate.annotations.GenericGenerator;

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy= GenerationType.AUTO,generator="native")
    @GenericGenerator(name = "native",strategy = "native")
    private int id;
    private String email;
    private String pwd;
    private String role;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }
}

// Repository

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.example.springsecurity61.model.Customer;

import java.util.List;

@Repository
public interface CustomerRepository extends CrudRepository<Customer,Long> {

    List<Customer> findByEmail(String email);

}

// UserDetail 추가
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
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.Service;

import com.example.springsecurity61.model.Customer;
import com.example.springsecurity61.repository.CustomerRepository;

import java.util.ArrayList;
import java.util.List;

@Service
public class EazyBankUserDetails implements UserDetailsService {

    @Autowired
    private CustomerRepository customerRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        String userName, password;
        List<GrantedAuthority> authorities;
        List<Customer> customer = customerRepository.findByEmail(username);
        if (customer.size() == 0) {
            throw new UsernameNotFoundException("User details not found for the user : " + username);
        } else{
            userName = customer.get(0).getEmail();
            password = customer.get(0).getPwd();
            authorities = new ArrayList<>();
            authorities.add(new SimpleGrantedAuthority(customer.get(0).getRole()));
        }
        return new User(userName,password,authorities);
    }

}

🟢 구조

망할. 예전 코드가 또 deprecated 됐다. 스프링 부트가 버전 업 하면서 코드가 바뀌고, Spring Security가 버전 업 하면서 코드가 또 바뀐다.

스택오버플로우, 블로그에서 코드 복사해서 붙여넣고 수정하는 것도 힘들다. 내 유일한 선임 개발자이자 선생님인 ChatGPT에게 물어보니 2021년 예전 코드만 알려준다.

나에게 남은 선택은 기초부터 파악하기! 게임 스테이지 분석처럼 스프링 시큐리티도 한번 까 보자.

✅ Spring Security Internal Flow

출처: https://www.youtube.com/@jgeek-xr6sy

이미지에 나온 스텝을 하나씩 해석해 보았다. (ChatGPT 선생님 번역본)

✅STEP 1: (사용자가 자격 증명 입력)

사용자가 로그인을 위해 자격 증명(예: 사용자 이름과 비밀번호)을 제출합니다.

✅STEP 2: (Spring Security Filters - Authentication / 스프링 보안 필터 - 인증)

자격 증명이 포함된 요청이 스프링 보안의 필터 체인에 의해 가로채져 인증 프로세스가 시작됩니다.

✅STEP 3: (Authentication Manager / 인증 관리자)

AuthenticationManager가 인증 프로세스를 관리하며, 올바른 인증 제공자(AuthenticationProvider)로 요청을 전달합니다.

✅STEP 4: (Authentication Providers / 인증 제공자)

AuthenticationManager는 제공된 자격 증명으로 요청을 인증하는 책임이 있는 하나 이상의 AuthenticationProvider 구현체에게 위임합니다.

✅STEP 5: (UserDetails Manager/Service)

UserDetailsService가 호출되어 사용자의 세부 정보(예: 역할 및 권한)를 데이터베이스 또는 기타 데이터 소스에서 로드합니다.

✅STEP 6: (PasswordEncoder / 비밀번호인코더)

PasswordEncoder는 제공된 비밀번호가 사용자에 대해 저장된 비밀번호와 일치하는지 확인하거나 인코딩하는 데 사용됩니다.

✅STEP 7: (인증 관리자로 돌아감)

AuthenticationProvider** 는 인증된 객체를 **AuthenticationManager에 반환하여 인증이 성공했음을 나타냅니다.

✅STEP 8: (스프링 보안 필터로 돌아감)

AuthenticationManager는 사용자가 인증되었음을 나타내어 스프링 보안 필터 체인에 제어를 반환합니다.

✅STEP 9: (보안 컨텍스트)

인증된 사용자의 세부 정보가 세션의 보안 컨텍스트를 보유하고 있는 SecurityContextHolder에 저장됩니다.

✅STEP 10: (사용자)

요청이 대상 리소스(예: 컨트롤러 메서드)로 전달되고 사용자는 애플리케이션의 보안 부분에 접근할 수 있는 권한을 부여받습니다.

😤그래서 뭐하는 놈들?

🟢 스프링 보안 필터 (Spring Security Filters)

스프링 보안 필터들은 각 요청을 가로채어 인증이 필요한지 확인합니다. 인증이 필요하면 사용자를 로그인 페이지로 이동시키거나 초기 인증 중 저장된 정보를 사용합니다.

🟢 인증 (Authentication)

UsernamePasswordAuthenticationFilter와 같은 필터는 HTTP 요청에서 사용자 이름/비밀번호를 추출하여 인증 객체를 준비합니다. 인증은 스프링 보안 프레임워크 내에서 인증된 사용자 정보를 저장하는 핵심 표준입니다.

🟢 인증 관리자 (AuthenticationManager)

필터에서 요청을 받으면, 사용자 정보의 유효성 검사를 사용 가능한 인증 제공자들에게 위임합니다. 앱 내에 여러 제공자가 있을 수 있으므로, 인증 관리자가 모든 인증 제공자를 관리하는 책임이 있습니다.

🟢 인증 제공자 (AuthenticationProvider)

인증 제공자는 사용자 정보를 인증하기 위한 핵심 로직을 가지고 있습니다.

🟢 UserDetailsManager/UserDetailsService

UserDetailsManager와 UserDetailsService는 DB/저장 시스템에서 사용자 정보를 검색, 생성, 업데이트, 삭제하는 데 사용이 됩니다.

🟢 PasswordEncoder

비밀번호를 인코딩하고 해싱하는 데 도움이 되는 서비스 인터페이스입니다. 그렇지 않으면 평문 비밀번호로 사용해야 할 수도 있습니다.

🟢 보안 컨텍스트 (SecurityContext)

요청이 인증되면 인증 정보는 일반적으로 SecurityContextHolder에 의해 관리되는 스레드 로컬 보안 컨텍스트에 저장됩니다. 이는 동일한 사용자로부터의 다가오는 요청을 처리하는 데 사용이 됩니다.

실습

🟡 시나리오 /contact, /notics 는 누구나 접근 가능 /myAccount, /myBalance, /myLoans, /myCards는 시큐리티 적용

🔵 구조

스프링 부트 : 3.1.2 버전 + Gradle (8.2.x) 자바 : 17 (OpenJDK)

🔵 코드

config - ProjectSecurityConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class ProjectSecurityConfig {

    @Bean
    SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

        /**
         *  *authorizeHttpRequests 설정*
         *  my 으로 시작하는 URL은 접근 권한 필요
         *  notices, contact는 누구나 접근 가능
         *  
         */

          http.authorizeHttpRequests( (requests) ->
                                          requests.requestMatchers("/myAccount","/myBalance","/myLoans","/myCards").authenticated() 
                                                  .requestMatchers("/notices","/contact").permitAll() )
                                      .formLogin(Customizer.withDefaults()) 
                                      .httpBasic(Customizer.withDefaults());
        return http.build();

        /**
         *  모든 request 거절
         *  Configuration to deny all the requests
         */
        /*http.authorizeHttpRequests(requests -> requests.anyRequest().denyAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();*/

        /**
         *     모든 request 허락
         *  Configuration to permit all the requests
         */
        /*http.authorizeHttpRequests(requests -> requests.anyRequest().permitAll())
                .formLogin(Customizer.withDefaults())
                .httpBasic(Customizer.withDefaults());
        return http.build();*/

    }




}

application.properties

spring.security.user.name = test1
spring.security.user.password = 123123

controller - NoticesController

package com.example.springsecurity6.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class NoticesController {

    @GetMapping("/notices")
    public String getNotices() {
        return "Here are the notices details from the DB";
    }

}

controller - AccountController

package com.example.springsecurity6.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AccountController {

    @GetMapping("/myAccount")
    public String getAccountDetails() {
        return "Here are the account details from the DB";
    }

}

build.gradle

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.1.2'
    id 'io.spring.dependency-management' version '1.1.2'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // spring security basic
    implementation 'org.springframework.boot:spring-boot-starter-security'
    testImplementation 'org.springframework.security:spring-security-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

🟣 결과

/myAccount 접속 시, /login 으로 이동

test1 / 123123 입력 후

스프링 시큐리티 6 기본 셋팅을 해보았다. 다음에는 JPA, MySQL을 이용해서 설정을 해보자.