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

ajax가 아예 진행이 안되서 질문드립니다.

springSecurity6, 스프링부트 3.2.1 사용중입니다.

코드는 아래와 같은데 이게 어디서 어디가 틀렸는지를 도저히 모르겠습니다.

ajax 전까지 form 방식은 정상적으로 작동하고 있으며,

ajax 요청 보낼 시

POST http://localhost:8080/api/login

org.apache.http.client.ClientProtocolException

이런 에러가 발생합니다. ajax.http 파일은 강의 문서를 다시 다운받아 했으며

postman으로 요청시 이유는 모르겠지만 get 요청으로 처리되고

위의 요청시 아래와 같은 로그 발생합니다

10000자 제한떄문에 댓글로 변경

curl 요청시 아래와 같습니다

10000자 제한떄문에 댓글로 변경

아래 코드에서 csrf disable을 하였음에도 계속 동일한 상태이고

강의 git 코드를 여러 브랜치에서 계속 참고해서 막 섞여있어서 어디서부터 고쳐야될지 전혀 모르겠습니다.

거의 6시간 넘게 헤매고 있는데 전혀 모르겠습니다.

혹시 확인 가능하시면 변경해야될 부분 부탁드립니다. 감사합니다.

@Configuration
@Slf4j
@Order(0)
public class AjaxSecurityConfig {

    @Autowired
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(authenticationProvider);
    }

    @Qualifier("ajaxAuthenticationProvider")
    @Autowired
    private AuthenticationProvider authenticationProvider; // 변경된 부분

    @Bean
    protected SecurityFilterChain filterChain(HttpSecurity http) throws  Exception {

        log.info("여기옴2");
        http
                .authorizeHttpRequests(auth->
                        auth
                                .requestMatchers("/api/login").permitAll()
                                .anyRequest().authenticated()
                );

        http.exceptionHandling(exceptionHandling ->
                exceptionHandling
                        .authenticationEntryPoint(new AjaxLoginAuthenticationEntryPoint())
                        .accessDeniedHandler(ajaxAccessDeniedHandler())
        );


        http.addFilterBefore(ajaxLoginProcessingFilter(), UsernamePasswordAuthenticationFilter.class);

        http.csrf(csrf -> csrf.disable());



        return http.build();
    }

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private AuthenticationConfiguration authenticationConfiguration;

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


    @Bean
    public AuthenticationSuccessHandler ajaxAuthenticationSuccessHandler(){
        return new AjaxAuthenticationSuccessHandler();
    }

    @Bean
    public AuthenticationFailureHandler ajaxAuthenticationFailureHandler(){
        return new AjaxAuthenticationFailureHandler();
    }

    public AccessDeniedHandler ajaxAccessDeniedHandler() {
        return new AjaxAccessDeniedHandler();
    }
    @Bean
    public AjaxLoginProcessingFilter ajaxLoginProcessingFilter() throws Exception {
        AjaxLoginProcessingFilter filter = new AjaxLoginProcessingFilter();
        filter.setAuthenticationManager(authenticationManager(authenticationConfiguration));
        filter.setAuthenticationSuccessHandler(ajaxAuthenticationSuccessHandler());
        filter.setAuthenticationFailureHandler(ajaxAuthenticationFailureHandler());
        return filter;
    }


//    @Bean
//    public AjaxLoginProcessingFilter ajaxLoginProcessingFilter(){
//        AjaxLoginProcessingFilter ajaxLoginProcessingFilter =  new AjaxLoginProcessingFilter();
//        ajaxLoginProcessingFilter.setAuthenticationManager(authenticationManagerBean());
//        return ajaxLoginProcessingFilter;
//    }
}

@Slf4j
@Component
public class AjaxAuthenticationProvider implements AuthenticationProvider {
    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    /**
     * 검증에 대한 구현 부분
     *
     * 여기서 전달받는 authentication 객체는 AuthenticationManager에서 전달받는 것
     * @param authentication the authentication request object.
     * @return
     * @throws AuthenticationException
     */
    @Transactional
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {

        String username = authentication.getName();
        String password = (String) authentication.getCredentials();

        log.info("ajax Authentication"+ authentication);
        log.info("ajax username : "+username);
        log.info("ajax password : "+password);

        /**
         * db에 있는 사용자를 가져오는 부분
         */
        AccountContext accountContext = (AccountContext)userDetailsService.loadUserByUsername(username);
        if (!passwordEncoder.matches(password, accountContext.getPassword())){
            throw new BadCredentialsException("ajax invalid password!");
        }

        /**
         * 섹션 4-8에서 secret key 추가해서 검증하는 부분
         */
//        FormWebAuthenticationDetails formWebAuthenticationDetails = (FormWebAuthenticationDetails) authentication.getDetails();
//        String secretKey = formWebAuthenticationDetails.getSecretKey();
//
//        if (secretKey == null || !"secret123".equals(secretKey)){
//            throw new InsufficientAuthenticationException("secret key invalid");
//        }

        AjaxAuthenticationToken authenticationToken = new AjaxAuthenticationToken(accountContext.getAccount(),null,accountContext.getAuthorities());

//        log.info(""+accountContext.getAccount());
//        log.info(""+authenticationToken);
        return authenticationToken;
    }

    /**
     * parameter 로 전달되는 authentication 타입과 여기서 검증하려는 대상의 타입이 일치하면 검증하도록 하는거
     * @param authentication
     * @return
     */
    @Override
    public boolean supports(Class<?> authentication) {
        return authentication.equals(AjaxAuthenticationToken.class);
    }
}

public class AjaxAuthenticationToken extends AbstractAuthenticationToken {
    private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;

    private final Object principal;

    private Object credentials;

    /**
     * 인증받기전에 사용자가 입력한 아이디와 비밀번호 담는 생성자
     *
     */
    public AjaxAuthenticationToken(Object principal, Object credentials) {
        super(null);
        this.principal = principal;
        this.credentials = credentials;
        setAuthenticated(false);
    }

    /**
     * 여기는 인증 완료후 아이디와 비번, 권한정보를 담는 생성자
     */
    public AjaxAuthenticationToken(Object principal, Object credentials,
                                               Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.principal = principal;
        this.credentials = credentials;
        super.setAuthenticated(true); // must use super, as we override
    }


    public static UsernamePasswordAuthenticationToken unauthenticated(Object principal, Object credentials) {
        return new UsernamePasswordAuthenticationToken(principal, credentials);
    }


    public static UsernamePasswordAuthenticationToken authenticated(Object principal, Object credentials,
                                                                    Collection<? extends GrantedAuthority> authorities) {
        return new UsernamePasswordAuthenticationToken(principal, credentials, authorities);
    }

    @Override
    public Object getCredentials() {
        return this.credentials;
    }

    @Override
    public Object getPrincipal() {
        return this.principal;
    }

    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
        Assert.isTrue(!isAuthenticated,
                "Cannot set this token to trusted - use constructor which takes a GrantedAuthority list instead");
        super.setAuthenticated(false);
    }

    @Override
    public void eraseCredentials() {
        super.eraseCredentials();
        this.credentials = null;
    }


}

@Slf4j
public class AjaxLoginProcessingFilter extends AbstractAuthenticationProcessingFilter {

    private ObjectMapper objectMapper = new ObjectMapper();

    private static final String XML_HTTP_REQUEST = "XMLHttpRequest";
    private static final String X_REQUESTED_WITH = "X-Requested-With";


    public AjaxLoginProcessingFilter() {
        /**
         * 여기서 정한 경로의 요청만 받음
         * 여기서 path 가 일치해야만 수행함
         */
        super(new AntPathRequestMatcher("/login", "POST"));
    }

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

        log.info("isAjax processing");
        if (isAjax(request)){
            throw new IllegalStateException("Authentication is not supported");
        }

        AccountDto accountDto = objectMapper.readValue(request.getReader(), AccountDto.class);

        /**
         * accountDto 비어있는지 확인하는 부분인데 StringUtils.isEmpty 가 deprecated 되어서 ObjectUtils.isEmpty 사용
         */
        if (ObjectUtils.isEmpty(accountDto.getUsername()) || ObjectUtils.isEmpty(accountDto.getPassword())){
            throw new AuthenticationServiceException("Username op Password is empty");
        }

        AjaxAuthenticationToken token = new AjaxAuthenticationToken(accountDto.getUsername(), accountDto.getPassword());

        return this.getAuthenticationManager().authenticate(token);
    }

    /**
     * 클라이언트와 약속 정해서
     * 그게 참이면 ajax 요청이 맞다고 판단함
     * @param request
     * @return
     */
    private boolean isAjax(HttpServletRequest request) {
        return "XMLHttpRequest".equals(request.getHeader("X-Requested-With"));
    }

}