Federsicherheit CORS Filter

Seit Spring Security 4.1 ist dies der richtige Weg, um Spring Security CORS zu unterstützen (wird auch in Spring Boot 1.4/1.5 benötigt):

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedMethods("HEAD", "GET", "PUT", "POST", "DELETE", "PATCH");
    }
}

und:

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
//        http.csrf().disable();
        http.cors();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        final CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(ImmutableList.of("*"));
        configuration.setAllowedMethods(ImmutableList.of("HEAD",
                "GET", "POST", "PUT", "DELETE", "PATCH"));
        // setAllowCredentials(true) is important, otherwise:
        // The value of the 'Access-Control-Allow-Origin' header in the response must not be the wildcard '*' when the request's credentials mode is 'include'.
        configuration.setAllowCredentials(true);
        // setAllowedHeaders is important! Without it, OPTIONS preflight request
        // will fail with 403 Invalid CORS request
        configuration.setAllowedHeaders(ImmutableList.of("Authorization", "Cache-Control", "Content-Type"));
        final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Tun Sie nichts , was der falsche Weg ist, um das Problem zu lösen:

• http.authorizeRequests().antMatchers(HttpMethod.OPTIONS, "/**").permitAll();
• web.ignoring().antMatchers(HttpMethod.OPTIONS);

Referenz: http://docs.spring.io/spring-security/site/docs/4.2.x/reference/html/cors.html

Da ich Probleme mit den anderen Lösungen hatte (vor allem, damit es in allen Browsern funktioniert, erkennt Edge beispielsweise "*" nicht als gültigen Wert für "Access-Control-Allow-Methods"), musste ich einen benutzerdefinierten Wert verwenden Filter Component, die am Ende für mich gearbeitet hat und genau das gemacht hat, was ich erreichen wollte.

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CorsFilter implements Filter {
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest request = (HttpServletRequest) req;
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods",
                "ACL, CANCELUPLOAD, CHECKIN, CHECKOUT, COPY, DELETE, GET, HEAD, LOCK, MKCALENDAR, MKCOL, MOVE, OPTIONS, POST, PROPFIND, PROPPATCH, PUT, REPORT, SEARCH, UNCHECKOUT, UNLOCK, UPDATE, VERSION-CONTROL");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers",
                "Origin, X-Requested-With, Content-Type, Accept, Key, Authorization");

        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            chain.doFilter(req, res);
        }
    }

    public void init(FilterConfig filterConfig) {
        // not needed
    }

    public void destroy() {
        //not needed
    }

}

1. Sie brauchen nicht:

   @Configuration
   @ComponentScan("com.company.praktikant")
   

   @EnableWebSecurity enthält bereits @Configuration, und ich kann mir nicht vorstellen, warum Sie @ComponentScan dort ablegen.

2. Über den CORS-Filter würde ich nur folgendes sagen:

   @Bean
   public FilterRegistrationBean corsFilter() {
       UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
       CorsConfiguration config = new CorsConfiguration();
       config.setAllowCredentials(true);
       config.addAllowedOrigin("*");
       config.addAllowedHeader("*");
       config.addAllowedMethod("*");
       source.registerCorsConfiguration("/**", config);
       FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
       bean.setOrder(0); 
       return bean;
   }
   

   In die SecurityConfiguration-Klasse und entfernen Sie globale Methoden. Sie müssen die Erlaubnis-Orgins, Header und Methoden nicht zweimal festlegen. Vor allem, wenn Sie unterschiedliche Eigenschaften in die Filter- und Federkonfigurationskonfiguration setzen :)

3. Laut oben ist Ihre "MyFilter" -Klasse redundant.

4. Sie können diese auch entfernen:

   final AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
   annotationConfigApplicationContext.register(CORSConfig.class);
   annotationConfigApplicationContext.refresh();
   

   Aus der Anwendungsklasse.

5. Am Ende kleiner Rat - nicht mit der Frage verbunden. Sie möchten keine Verben in URI einfügen. Anstelle von http://localhost:8080/getKunden sollten Sie die HTTP-GET-Methode für http://localhost:8080/kunden-Ressource verwenden. Best Practices für das Design von RESTful-API erfahren Sie hier: http://www.vinaysahni.com/best-practices-for-a-pragmatic-restful-api

Mit Spring Security in Spring Boot 2 können Sie CORS global konfigurieren (z. B. alle Entwicklungsanforderungen aktivieren).

@Bean
protected CorsConfigurationSource corsConfigurationSource() {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", new CorsConfiguration().applyPermitDefaultValues());
    return source;
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.cors()
            .and().authorizeRequests()
            .anyRequest().permitAll()
            .and().csrf().disable();
}

Gemäß der CORS-Filterdokumentation :

"Spring MVC bietet eine fein abgestimmte Unterstützung für die CORS-Konfiguration .__ durch Annotationen auf Controllern. Wenn jedoch mit Spring Verwendet wird, ist es ratsam, sich auf den eingebauten CorsFilter zu verlassen, der bestellt werden muss .__ vor der Filterkette von Spring Security "

So etwas erlaubt GET den Zugriff auf den /ajaxUri:

import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

import Java.util.Arrays;

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class AjaxCorsFilter extends CorsFilter {
    public AjaxCorsFilter() {
        super(configurationSource());
    }

    private static UrlBasedCorsConfigurationSource configurationSource() {
        CorsConfiguration config = new CorsConfiguration();

        // origins
        config.addAllowedOrigin("*");

        // when using ajax: withCredentials: true, we require exact Origin match
        config.setAllowCredentials(true);

        // headers
        config.addAllowedHeader("x-requested-with");

        // methods
        config.addAllowedMethod(HttpMethod.OPTIONS);
        config.addAllowedMethod(HttpMethod.GET);

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/startAsyncAuthorize", config);
        source.registerCorsConfiguration("/ajaxUri", config);
        return source;
    }
}

Natürlich muss Ihre SpringSecurity-Konfiguration den Zugriff auf den URI mit den aufgelisteten Methoden ermöglichen. Siehe @Hendy Irawan Antwort.

An vielen Stellen sehe ich die Antwort, die diesen Code hinzufügen muss: 

@Bean
public FilterRegistrationBean corsFilter() {
   UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
   CorsConfiguration config = new CorsConfiguration();
   config.setAllowCredentials(true);
   config.addAllowedOrigin("*");
   config.addAllowedHeader("*");
   config.addAllowedMethod("*");
   source.registerCorsConfiguration("/**", config);
   FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
   bean.setOrder(0); 
   return bean;
}

in meinem Fall löst es jedoch eine unerwartete Ausnahme vom Klassentyp aus. corsFilter() bean benötigt den Typ CorsFilter, also habe ich diese Änderungen vorgenommen und diese Definition von bean in meine config gesetzt. Jetzt ist alles in Ordnung.

@Bean
public CorsFilter corsFilter() {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.addAllowedOrigin("*");
    config.addAllowedHeader("*");
    config.addAllowedMethod("*");
    source.registerCorsConfiguration("/**", config);
    return new CorsFilter(source);
}

In meinem Fall habe ich diese Klasse gerade hinzugefügt und @EnableAutConfiguration verwendet

package com.package.filter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
import Java.io.IOException;


 @Component
 public class SimpleCORSFilter extends GenericFilterBean {

/**
 * The Logger for this class.
 */
private final Logger logger = LoggerFactory.getLogger(this.getClass());

@Override
public void doFilter(ServletRequest req, ServletResponse resp,
                     FilterChain chain) throws IOException, ServletException {
    logger.info("> doFilter");

    HttpServletResponse response = (HttpServletResponse) resp;
    response.setHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Methods", "POST, PUT, GET, OPTIONS, DELETE");
    response.setHeader("Access-Control-Max-Age", "3600");
    response.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
    //response.setHeader("Access-Control-Allow-Credentials", "true");
    chain.doFilter(req, resp);

    logger.info("< doFilter");
}

}

Für bereits implementierte Programme, die sich Codeänderungen nicht leisten können (z. B. Federsicherheit hinzufügen/aktualisieren), ist das Hinzufügen eines einfachen Proxy eine Lösung: https://stackoverflow.com/a/49827300/1758194