Standalone Spring OAuth2 JWT Authorization Server + CORS

j'ai trouvé une solution en utilisant la solution pour la question. Mais j'ai une autre façon de décrire la solution:

@Configuration
public class WebSecurityGlobalConfig extends WebSecurityConfigurerAdapter {
      ....
      @Override
      public void configure(WebSecurity web) throws Exception {
        web.ignoring()
          .antMatchers(HttpMethod.OPTIONS);
      }
      ...
}

je suis tombé sur une question similaire en utilisant la suite

• Backend Spring Boot 1.5.8.RELEASE
• Spring OAuth2 Spring OAuth 2.2.0.RELEASE w
• Vuejs app à l'aide de axios requête ajax library

avec postman tout fonctionne! Quand j'ai commencé à faire la demande de Vuejs app puis j'ai eu les erreurs suivantes

OPTIONS http://localhost:8080/springboot/oauth/token 401 ()

et

XMLHttpRequest ne peut pas charger http://localhost:8080/springboot/oauth/token . La réponse pour preflight a un code D'état HTTP non valide 401

après un peu de lecture, j'ai découvert que je peux donner instruction à mon Spring OAuth d'ignorer la demande OPTIONS en outrepassant configure dans mon WebSecurityConfigurerAdapter la mise en œuvre de la classe ainsi

@Override
public void configure(WebSecurity web) throws Exception {
   web.ignoring().antMatchers(HttpMethod.OPTIONS);
}

L'ajout de ce qui précède a aidé, mais alors, je suis tombé sur le CORS erreur spécifique

OPTIONS http://localhost:8080/springboot/oauth/token 403 ()

et

XMLHttpRequest cannot load"" http://localhost:8080/springboot/oauth/token . Réponse à la requête preflight ne passe pas la vérification du contrôle d'accès: aucun en-tête 'Access-Control-Allow-Origin' n'est présent sur la ressource demandée. Origine " http://localhost:8000 " n'est donc pas autorisé à y accéder. La réponse contenait le code de statut HTTP 403.

et a résolu le problème ci-dessus à l'aide d'un CorsConfig comme indiqué ci-dessous

@Configuration
public class CorsConfig {
    @Bean
    public FilterRegistrationBean corsFilterRegistrationBean() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.applyPermitDefaultValues();
        config.setAllowCredentials(true);
        config.setAllowedOrigins(Arrays.asList("*"));
        config.setAllowedHeaders(Arrays.asList("*"));
        config.setAllowedMethods(Arrays.asList("*"));
        config.setExposedHeaders(Arrays.asList("content-length"));
        config.setMaxAge(3600L);
        source.registerCorsConfiguration("/**", config);
        FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
        bean.setOrder(0);
        return bean;
    }
}

Après l'ajout de la classe ci-dessus, il fonctionne comme prévu. Avant que je vais prod je vais rechercher consequences de l'utilisation de

web.ignoring().antMatchers(HttpMethod.OPTIONS);

ainsi que best practices pour la configuration ci-dessus Cors . Pour l'instant * fait le travail mais, certainement pas sûr pour la production.

la réponse de Cyril m'a aidé partially et puis je suis tombé sur le CorsConfig idée dans ce Github de l'émission.

vous avez raison! c'est une solution, et ça a marché aussi pour moi (j'avais le même problème)

mais laissez-moi sussgest d'utiliser une plus intelligente CORS mise en œuvre de filtre pour Java: http://software.dzhuvinov.com/cors-filter.html

c'est une solution très complète pour les applications Java.

en fait, vous pouvez voir ici comment votre point est résolu.

en utilisant la botte à ressort 2 ici.

j'ai dû le faire dans mon AuthorizationServerConfigurerAdapter

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) {

    Map<String, CorsConfiguration> corsConfigMap = new HashMap<>();
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    //TODO: Make configurable
    config.setAllowedOrigins(Collections.singletonList("*"));
    config.setAllowedMethods(Collections.singletonList("*"));
    config.setAllowedHeaders(Collections.singletonList("*"));
    corsConfigMap.put("/oauth/token", config);
    endpoints.getFrameworkEndpointHandlerMapping()
            .setCorsConfigurations(corsConfigMap);

    //additional settings...
}

utilisant la botte de printemps comme un serveur de OAuth avec la sécurité de ressort et SSL pour un backend RESTful. C'est dur d'essayer de relier ça, surtout avec CORS. Je pense que l'exclusion de la config mvc peut avoir perdu une partie de la configuration du CORS automatique.

ajouter manuellement un filtre CORS tel que décrit dans les autres réponses a fonctionné pour moi. Cependant, je devais aussi ajouter:

@Override
public void configure(AuthorizationServerSecurityConfigurer oauthServer) {
    // Disable /oauth/token Http Basic Auth
    oauthServer.allowFormAuthenticationForClients();
}

avec ce bit ajouté, je pourrais laisser tomber mon filtre CORS personnalisé et ajouter le configuration suggérée par la réponse de Sebastiaan:

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
    // Workaround for https://github.com/spring-projects/spring-boot/issues/1801
    endpoints.authenticationManager(authentication -> authenticationManager.getOrBuild().authenticate(authentication));
    endpoints.getFrameworkEndpointHandlerMapping().setCorsConfigurations(getCorsConfig());
}

private Map<String, CorsConfiguration> getCorsConfig() {

    List<String> methodsList = Stream.of("GET", "POST", "PUT", "DELETE", "OPTIONS").collect(Collectors.toList());
    List<String> allowableOriginsList = Stream.of("*").collect(Collectors.toList());
    List<String> allowableHeadersList =
            Stream.of("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
            .collect(Collectors.toList());

    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.setAllowedOrigins(allowableOriginsList);
    config.setAllowedMethods(methodsList);
    config.setAllowedHeaders(allowableHeadersList);

    Map<String, CorsConfiguration> corsConfigMap = new HashMap<>();
    corsConfigMap.put("/oauth/token", config);

    return corsConfigMap;
}

puis il n'y avait plus besoin d'utiliser le WebSecurityConfigurerAdapter (tout peut maintenant vivre dans AuthorizationServerConfigurerAdapter ) et ce morceau pourrait être enlevé:

public class MyWebSecurity extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http
          .authorizeRequests()
          .antMatchers(HttpMethod.OPTIONS, "/oauth/token").permitAll();
   }
}