Comment configurer la SCRO, au Printemps de Démarrage + Printemps application de Sécurité?

Printemps de Sécurité peuvent désormais tirer parti de Spring MVC, le soutien de la SCRO décrit dans ce blog j'ai écrit.

Pour le faire fonctionner, vous devez activer explicitement le soutien de la SCRO au Printemps de Sécurité au niveau suivant, sinon de la SCRO activé, les demandes peuvent être bloqués par le Printemps de Sécurité avant d'atteindre Spring MVC.

Si vous utilisez un contrôleur de niveau @CrossOrigin annotations, vous avez juste à activer le Printemps de Sécurité le soutien de la SCRO et mettra à profit les Spring MVC configuration:

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and()...
    }
}

Si vous préférez l'utilisation de la SCRO mondial de configuration, vous pouvez déclarer une CorsConfigurationSource bean comme suit:

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and()...
    }

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

Cette approche remplace le filtre approche fondée sur les recommandé précédemment.

Vous pouvez trouver plus de détails dans la dédié de la SCRO section de Printemps de Sécurité de la documentation.

Si vous utilisez le Printemps de Sécurité, vous pouvez effectuer les opérations suivantes pour s'assurer que la SCRO les demandes sont traitées en premier:

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            //by default uses a Bean by the name of corsConfigurationSource
            .cors().and()
            ...
    }

    @Bean
    CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("https://example.com"));
        configuration.setAllowedMethods(Arrays.asList("GET","POST"));
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Voir Printemps 4.2.x de la SCRO pour plus d'informations.

Pour la configuration des propriétés de

# ENDPOINTS CORS CONFIGURATION (EndpointCorsProperties)
endpoints.cors.allow-credentials= # Set whether credentials are supported. When not set, credentials are not supported.
endpoints.cors.allowed-headers= # Comma-separated list of headers to allow in a request. '*' allows all headers.
endpoints.cors.allowed-methods=GET # Comma-separated list of methods to allow. '*' allows all methods.
endpoints.cors.allowed-origins= # Comma-separated list of origins to allow. '*' allows all origins. When not set, CORS support is disabled.
endpoints.cors.exposed-headers= # Comma-separated list of headers to include in a response.
endpoints.cors.max-age=1800 # How long, in seconds, the response from a pre-flight request can be cached by clients.

J'ai résolu ce problème en:

@Configuration
public class CORSFilter extends CorsFilter {

    public CORSFilter(CorsConfigurationSource source) {
        super((CorsConfigurationSource) source);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        response.addHeader("Access-Control-Allow-Headers",
                "Access-Control-Allow-Origin, Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers");
        if (response.getHeader("Access-Control-Allow-Origin") == null)
            response.addHeader("Access-Control-Allow-Origin", "*");
        filterChain.doFilter(request, response);
    }

}

et:

@Configuration
public class RestConfig {

    @Bean
    public CORSFilter corsFilter() {
        CorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("http://localhost:4200");
        config.addAllowedMethod(HttpMethod.DELETE);
        config.addAllowedMethod(HttpMethod.GET);
        config.addAllowedMethod(HttpMethod.OPTIONS);
        config.addAllowedMethod(HttpMethod.PUT);
        config.addAllowedMethod(HttpMethod.POST);
        ((UrlBasedCorsConfigurationSource) source).registerCorsConfiguration("/**", config);
        return new CORSFilter(source);
    }
}

De la scro peut être une douleur dans le cul, mais avec ce simple code vous de la Scro SEULEMENT!!!!!!! à la à la méthode spécifiée

@CrossOrigin(origins="*")//in this line add your url and thats is all for spring boot side
    @GetMapping("/some")
    public String index() {
        return "pawned cors!!!!";
    }

Comme un charme au printemps de démarrage 2.0.2

J'ai eu de gros problèmes avec Axios, le Printemps de Démarrage et de la Sécurité Printemps avec authentification.

Veuillez noter que la version de Printemps de Démarrage et le Printemps de Sécurité, vous êtes à l'aide de questions.

Printemps De Démarrage: 1.5.10
Printemps: 4.3.14
Printemps De Sécurité 4.2.4

Pour résoudre ce problème à l'aide de l'Annotation Java Configuration que j'ai créé la classe suivante:

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {

        auth.inMemoryAuthentication()
                .withUser("youruser").password("yourpassword")
                .authorities("ROLE_USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.cors().and().
                authorizeRequests()
                .requestMatchers(CorsUtils:: isPreFlightRequest).permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .httpBasic()
                .realmName("Biometrix");

        http.csrf().disable();

    }

    @Bean
    CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowCredentials(true);
        configuration.setAllowedHeaders(Arrays.asList("Authorization"));
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("*"));
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

L'un des principaux problèmes avec Axios est que lorsque votre API requiert une authentification, il envoie un en-tête d'Autorisation à la demande OPTIONS. Si vous n'incluez pas l'Autorisation dans les en-têtes de configuration, les OPTIONS de demande (aka demande de contrôle en amont) échouera et Axios signale une erreur.

Comme vous pouvez le voir avec un couple de simple et placés correctement les paramètres de configuration de la SCRO avec SpringBoot est assez facile.

Après beaucoup de recherche de l'erreur venant de javascript de la SCRO, la seule solution que j'ai trouvé pour cette affaire était la configuration de la scro du Printemps de la même classe org.springframework.web.la scro.CorsConfiguration.CorsConfiguration()

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().configurationSource(request -> new CorsConfiguration().applyPermitDefaultValues());
    }