인프런 커뮤니티 질문&답변

전체 실행 코드 공유 부탁드립니다

import com.tripcoach.app_api.security.exception.JwtAuthenticationEntryPoint;
import com.tripcoach.app_api.security.filter.CustomAuthenticationFilter;
import com.tripcoach.app_api.security.filter.JwtAuthenticationFilter;
import com.tripcoach.app_api.security.handler.CustomAccessDeniedHandler;
import com.tripcoach.app_api.security.handler.CustomAuthenticationFailureHandler;
import com.tripcoach.app_api.security.handler.CustomAuthenticationSuccessHandler;
import com.tripcoach.app_api.security.provider.CustomAuthenticationManager;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.cors.CorsConfiguration;

import static com.tripcoach.core.common.apiresult.comcode.ComCode.PERMIT_ALL;
import static org.springframework.security.config.Customizer.withDefaults;

@RequiredArgsConstructor
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    private final JwtAuthenticationFilter jwtAuthenticationFilter;
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final CustomAccessDeniedHandler customAccessDeniedHandler;
    private final CustomAuthenticationSuccessHandler customAuthenticationSuccessHandler;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .csrf(AbstractHttpConfigurer::disable)
                .cors(withDefaults())
                .authorizeHttpRequests(authorizeRequests ->
                        authorizeRequests
                                .requestMatchers(PERMIT_ALL).permitAll()
                                .anyRequest().authenticated()
                )
                .exceptionHandling(exceptionHandling ->
                        exceptionHandling
                                .accessDeniedHandler(customAccessDeniedHandler)
                                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                )
                .sessionManagement(sessionManagement ->
                        sessionManagement
                                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                );

        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    // 커스텀 인증 필터
    @Bean
    public CustomAuthenticationFilter customAuthenticationProcessingFilter() {
        CustomAuthenticationFilter filter = new CustomAuthenticationFilter();
        filter.setAuthenticationManager(customAuthenticationManager());
        filter.setAuthenticationSuccessHandler(customAuthenticationSuccessHandler);
        filter.setAuthenticationFailureHandler(new CustomAuthenticationFailureHandler());
        return filter;
    }

    // 커스텀 인증 매니저
    @Bean
    public CustomAuthenticationManager customAuthenticationManager() {
        return new CustomAuthenticationManager();
    }
}

import com.fasterxml.jackson.annotation.JsonCreator;
import com.tripcoach.core.common.enumType.Constant;
import lombok.Data;
import lombok.Getter;

import java.util.Arrays;


public enum SecurityCode implements Constant {
    JWT_EXCEPTION("JWT_EXCEPTION", "JWT TOKEN 만료 되었거나 잘못 되었습니다."),
    EXPIRED_JWT_EXCEPTION("ExpiredJwtException", "토큰이 만료 되었습니다.\n토큰을 재발급 해주세요"),
    MALFORMED_JWT_EXCEPTION("MalformedJwtException", "손상된 토큰입니다.\n관리자에게 문의해주세요"),
    UNSUPPORTED_JWT_EXCEPTION("UnsupportedJwtException", "지원하지 않은 토큰 입니다."),
    SIGNATURE_EXCEPTION("SignatureException", "시그니처 검증에 실패한 토큰 입니다."),
    ILLEGAL_ARGUMENT_EXCEPTION("IllegalArgumentException", "관리자에게 문의해주세요"),
    NULL_POINT_EXCEPTION("NullPointException", "빈값 입니다");

    private final String label;
    private final String message;

    SecurityCode(String label, String message) {
        this.label = label;
        this.message = message;
    }

    public String label() {
        return label;
    }

    public String message() {
        return message;
    }

}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tripcoach.app_api.security.config.SecurityCode;
import com.tripcoach.core.common.apiresult.dto.ApiResult;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.PrintWriter;

import static com.tripcoach.app_api.security.config.SecurityCode.*;
import static com.tripcoach.core.common.apiresult.util.ApiUtils.error;
import static jakarta.servlet.http.HttpServletResponse.*;
import static org.apache.commons.codec.CharEncoding.UTF_8;


@Slf4j
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
        SecurityCode jwtException = (SecurityCode) request.getAttribute(JWT_EXCEPTION.label());

//        String errorMessage = getErrorMessage(jwtException);

        String errorMessage = "관리자에게 문의해주세요";
        int errorCode = 400;

        if (jwtException != null) {
            switch (jwtException) {
                case EXPIRED_JWT_EXCEPTION:
                    errorMessage = EXPIRED_JWT_EXCEPTION.message();
                    errorCode = 401;
                    break;
                case MALFORMED_JWT_EXCEPTION:
                    errorMessage = MALFORMED_JWT_EXCEPTION.message();
                    errorCode = 401;
                    break;
                case UNSUPPORTED_JWT_EXCEPTION:
                    errorMessage = UNSUPPORTED_JWT_EXCEPTION.message();
                    errorCode = 401;
                    break;
                case SIGNATURE_EXCEPTION:
                    errorMessage = SIGNATURE_EXCEPTION.message();
                    errorCode = 401;
                    break;
                case ILLEGAL_ARGUMENT_EXCEPTION:
                    errorMessage = ILLEGAL_ARGUMENT_EXCEPTION.message();
                    errorCode = 400;
                    break;
                case NULL_POINT_EXCEPTION:
                    errorMessage = NULL_POINT_EXCEPTION.message();
                    errorCode = 400;
                    break;
                default:
                    errorMessage = JWT_EXCEPTION.message(); // 기본적으로 설정할 메시지
                    errorCode = 500;
                    break;
            }
        }


        response.setContentType("application/json");
        response.setCharacterEncoding(UTF_8);
        response.setStatus(errorCode);
        ApiResult<?> error = error(request.getServletPath(), errorMessage, errorCode);
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(error);
        PrintWriter out = response.getWriter();
        out.print(jsonResponse);
        out.flush();
    }
}

import com.tripcoach.app_api.security.token.CustomAuthenticationToken;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
public class CustomAuthenticationFilter extends AbstractAuthenticationProcessingFilter {


    public CustomAuthenticationFilter() {
        super(new AntPathRequestMatcher("/login"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {


        String snsId = request.getParameter("snsId");
        String snsType = request.getParameter("snsType");
        String fcmToken = request.getParameter("fcmToken");
        String osType = request.getParameter("osType");

        CustomAuthenticationToken customToken = new CustomAuthenticationToken(snsId, snsType, fcmToken, osType);

        return getAuthenticationManager().authenticate(customToken);
    }

}

import com.tripcoach.app_api.security.provider.JwtTokenProvider;
import com.tripcoach.app_api.security.service.CustomUserDetailsServiceImpl;
import io.jsonwebtoken.Claims;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Slf4j
@RequiredArgsConstructor
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private static final String AUTHORIZATION_HEADER = "Authorization";
    private static final String BEARER_PREFIX = "Bearer ";
    private final CustomUserDetailsServiceImpl userDetailsService;
    private final JwtTokenProvider jwtTokenProvider;


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        final String requestTokenHeader = request.getHeader(AUTHORIZATION_HEADER);

        String username = null;
        String jwtToken = null;

        // JWT Token is in the form "Bearer token". Remove Bearer word and get only the Token
        if (requestTokenHeader != null && requestTokenHeader.startsWith(BEARER_PREFIX)) {
            try {
                jwtToken = requestTokenHeader.substring(7);
                Claims claims = jwtTokenProvider.getUsernameFromToken(jwtToken, request);
                username = claims.getSubject();
                String nickname = (String) claims.get("nickname");
                log.info("유저 인덱스 = {}  유저 닉네임 = {} ", username, nickname);
            } catch (NullPointerException e) {
                log.info("로그인 실패");
            }
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            // 토큰이 유효한 경우.. 수동으로 인증을 설정하도록 Spring Security를 구성
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            usernamePasswordAuthenticationToken
                    .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            // 컨텍스트에서 인증을 설정한 후, 현재 사용자가 인증되었음을 지정. Spring Security Configurations 성공적으로 통과.
            SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
        }
        chain.doFilter(request, response);
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        // 403 권한 거부 에러를 뱉는다.
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tripcoach.core.common.apiresult.dto.ApiResult;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;

import java.io.IOException;
import java.io.PrintWriter;

import static com.tripcoach.core.common.apiresult.comcode.ComCode.AUTH_FAIL_CODE;
import static com.tripcoach.core.common.apiresult.comcode.ComCode.LOGIN_FAIL;
import static com.tripcoach.core.common.apiresult.util.ApiUtils.error;


public class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        ApiResult<?> error = error(null, LOGIN_FAIL, AUTH_FAIL_CODE);

        // Convert the DTO to a JSON string
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(error);

        // Set the content type of the response to JSON
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");

        // Write the JSON string to the response body
        PrintWriter out = response.getWriter();
        out.print(jsonResponse);
        out.flush();
    }


}

@Slf4j
@RequiredArgsConstructor
@Service
public class CustomAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
    private final FlyingDistanceLogService flyingDistanceLogService;

    @Override
    public void onAuthenticationSuccess(final HttpServletRequest request, final HttpServletResponse response, final Authentication authentication) throws IOException {

        Member member = ((MemberContext) authentication.getPrincipal()).getMember();

        String token = new JwtTokenProvider().generateToken(member);
        LoginRespDto result = new LoginRespDto(member, token);

        ApiResult<LoginRespDto> success = success(result, SUCCESS, SUCCESS_CODE);

        // Convert the DTO to a JSON string
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(success);

        // Set the content type of the response to JSON
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");


        // Write the JSON string to the response body
        PrintWriter out = response.getWriter();
        out.print(jsonResponse);
        out.flush();

        // 로그인 성공했을때만 이력을 남김
        flyingDistanceLogService.loginLog(member);
    }
}

깃허브에서 받을 수 없나요

환경설정이나 실행에 필요한 코드 모두 필요합니다

회사 프로젝트여서 코드를 전체 드리기가 어려운점 이해부탁드리겠습니다 ㅠ

제가 이코드로 실행될수있게끔 프로젝트를 다시만들어서 공유드리겠습니다

 감사합니다