CORS-Problem - Keine "Access-Control-Allow-Origin' - header vorhanden ist, auf die angeforderte Ressource

Erstellt habe ich zwei web - Applikationen- Kunden-und service-apps.
Die Interaktion zwischen client und service-apps geht in Ordnung, wenn Sie eingesetzt werden, in derselben Tomcat-Instanz.
Aber wenn die apps bereitgestellt werden, in separate Tomcat-Instanzen (verschiedene Maschinen), bekomme ich die folgende Fehlermeldung, wenn Anfrage gesendet service-app.

Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource. 
Origin 'http://localhost:8080' is therefore not allowed access. The response had HTTP status code 401

Meine Client-Anwendung nutzt JQuery, HTML5 und Bootstrap.

AJAX-Aufruf gemacht, um service wie unten gezeigt:

var auth = "Basic " + btoa({usname} + ":" + {password});
var service_url = {serviceAppDomainName}/services;

if($("#registrationForm").valid()){
    var formData = JSON.stringify(getFormData(registrationForm));
    $.ajax({
        url: service_url+action,
        dataType: 'json',
        async: false,
        type: 'POST',
        headers:{
            "Authorization":auth
        },
        contentType: 'application/json',
        data: formData,
        success: function(data){
            //success code
        },
        error: function( jqXhr, textStatus, errorThrown ){
            alert( errorThrown );
        });
}

Mein service-Anwendung verwendet, Spring MVC, Spring Data JPA und Spring Security.

Ich habe CorsConfiguration Klasse, wie unten gezeigt:

CORSConfig.java:

@Configuration
@EnableWebMvc
public class CORSConfig extends WebMvcConfigurerAdapter  {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("*");
    }
}

SecurityConfig.java:

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
@ComponentScan(basePackages = "com.services", scopedProxy = ScopedProxyMode.INTERFACES)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    @Qualifier("authenticationService")
    private UserDetailsService userDetailsService;

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
       http
                .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().fullyAuthenticated();
        http.httpBasic();
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        http.csrf().disable();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
        authenticationProvider.setUserDetailsService(userDetailsService);
        authenticationProvider.setPasswordEncoder(passwordEncoder());
        return authenticationProvider;
    }
}

Spring Security-Abhängigkeiten:

 <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>3.2.3.RELEASE</version>
</dependency>
<dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>3.2.3.RELEASE</version>
</dependency>

Ich bin mit Apache Tomcat Servers für die Bereitstellung.

InformationsquelleAutor JavaDeveloper | 2017-02-03

11

CORS' preflight-request HTTP verwendet OPTIONS ohne Anmeldeinformationen finden Sie unter Cross-Origin Resource Sharing:
Ansonsten, machen Sie einen preflight-Anfrage. Holen Sie die Anfrage-URL, von Herkunft, Quelle, Ursprung, anhand der referrer-Quelle als override referrer-Quelle mit der manuellen redirect-flag und die cookies blockieren-flag gesetzt, mit der Methode OPTIONEN, und mit den folgenden zusätzlichen Einschränkungen:
- Enthalten ein " Access-Control-Request-Methode-header mit header-Feld Wert, die Anfrage-Methode (auch wenn, dass ist eine einfache Methode).
- Wenn der Autor-request-Header nicht leer ist, enthalten ein " Access-Control-Request-Headers-header mit header-Feld Wert eine Komma-separierte Liste von header-Feld, Namen von Autor-request-Header in lexikographische Ordnung, jede konvertierte ASCII-Kleinbuchstaben (auch wenn der eine oder mehr sind eine einfache header).
- Ausschließen, dass der Autor-request-Header.
- Ausschließen Anmeldeinformationen.
- Ausschließen, dass der request entity body.
Müssen Sie den anonymen Zugriff für den HTTP -OPTIONS.

Ihrer modifizierten (und vereinfachte) code:
```
@Override
protected void configure(HttpSecurity http) throws Exception {
   http
       .authorizeRequests()
           .andMatchers(HttpMethod.OPTIONS, "/**").permitAll()
           .antMatchers("/login").permitAll()
           .anyRequest().fullyAuthenticated()
           .and()
       .httpBasic()
           .and()
       .sessionManagement()
           .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
           .and()
       .csrf().disable();
}
```
Da Spring Security 4.2.0 können Sie die integrierte Unterstützung finden Spring Security Referenz:
19. CORS

Spring Framework bietet erstklassigen support für CORS. CORS verarbeitet werden müssen, bevor der Frühling die Sicherheit, da das pre-flight-request enthält keine cookies (d.h. die JSESSIONID). Wenn die Anforderung nicht enthalten, die cookies und Spring Security ist die erste, die Anforderung ermitteln der Benutzer nicht authentifiziert ist (da gibt es keine cookies in der Anforderung) und lehnen es ab.

Der einfachste Weg, um sicherzustellen, dass CORS behandelt erste ist die Verwendung der CorsFilter. Benutzer können die Integration der CorsFilter mit Spring Security, indem Sie eine CorsConfigurationSource mit den folgenden:
```
@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;
  }
}
```
.andMatchers(HttpMethod.OPTIONS, "/**").permitAll() nie für mich gearbeitet, es gab nicht die richtige CORS-Header auf OPTIONS. Nur das Spring Security-genehmigt CORS-Technik funktioniert.
Noch immer CORS-Fehler, wenn Sie versuchen, diese Lösung: [...] has been blocked by CORS policy: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource.

InformationsquelleAutor dur

Da Spring Security 4.1, das ist der richtige Weg, um Spring Security support CORS (auch in Spring-Boot-1.4/1.5):

@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 nicht haben unten, die sind der falsche Weg, zu versuchen, die Lösung des Problems:

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

Dies ist die einzige Antwort, die funktioniert. Mit Spring Boot 1.5.9 und Eckig 6
Arbeitete für mich, aber ich hatte für die Verwendung von http.csrf().disable (), weil iOS-und Android-Apps blockiert werden würde, wenn nicht aktiviert. Jetzt beide arbeiten, WEB und Mobile.

InformationsquelleAutor Hendy Irawan

In meinem Fall habe ich die Resource Server mit OAuth security aktiviert, und alle der oben genannten Lösungen nicht funktioniert hat. Nach einigem Debuggen und googeln herausgefunden, warum.

@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(Ordered.HIGHEST_PRECEDENCE);
    return bean;
}

Grundsätzlich in diesem Beispiel Ordered.HIGHEST_PRECEDENCE ist der Schlüssel!

https://github.com/spring-projects/spring-security-oauth/issues/938

Verschiedenen pom Abhängigkeiten hinzufügen von verschiedenen Arten von filtern und somit konnten wir Probleme haben basierend auf der Reihenfolge.

InformationsquelleAutor AntonIva

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.