Access-Control-Allow-Origin Wiele Domen Pochodzenia?

Inne rozwiązanie, którego używam w PHP:

$http_origin = $_SERVER['HTTP_ORIGIN'];

if ($http_origin == "http://www.domain1.com" || $http_origin == "http://www.domain2.com" || $http_origin == "http://www.domain3.com")
{  
    header("Access-Control-Allow-Origin: $http_origin");
}

To mi pomogło:

SetEnvIf Origin "^http(s)?://(.+\.)?(domain\.example|domain2\.example)$" origin_is=$0 
Header always set Access-Control-Allow-Origin %{origin_is}e env=origin_is

Po umieszczeniu .htaccess, będzie działać na pewno.

Miałem ten sam problem z czcionkami woff, wiele subdomen musiało mieć dostęp. Aby umożliwić subdomeny dodałem coś takiego do mojego httpd.conf:

SetEnvIf Origin "^(.*\.example\.com)$" ORIGIN_SUB_DOMAIN=$1
<FilesMatch "\.woff$">
    Header set Access-Control-Allow-Origin "%{ORIGIN_SUB_DOMAIN}e" env=ORIGIN_SUB_DOMAIN
</FilesMatch>

Dla wielu domen możesz po prostu zmienić wyrażenie regularne w SetEnvIf.

Jeśli chcesz, aby Twoja domena była zgodna z Nginx, jest to przydatne, jeśli chcesz obsługiwać czcionkę z wieloma sub-domenami:

location /fonts {
    # this will echo back the origin header
    if ($http_origin ~ "example.org$") {
        add_header "Access-Control-Allow-Origin" $http_origin;
    }
}

Oto co zrobiłem dla aplikacji PHP, o którą prosi AJAX

$request_headers        = apache_request_headers();
$http_origin            = $request_headers['Origin'];
$allowed_http_origins   = array(
                            "http://myDumbDomain.example"   ,
                            "http://anotherDumbDomain.example"  ,
                            "http://localhost"  ,
                          );
if (in_array($http_origin, $allowed_http_origins)){  
    @header("Access-Control-Allow-Origin: " . $http_origin);
}

Jeśli serwer zezwala na wysyłanie żądań, zwróć $http_origin jako wartość nagłówka Access-Control-Allow-Origin zamiast zwracać * wieloznaczną.

Jest jedna wada, o której powinieneś być świadomy: gdy tylko wyjedziesz z plików źródłowych na CDN (lub inny serwer, który nie pozwala na skrypty) lub jeśli Twoje pliki są buforowane na serwerze proxy, zmiana odpowiedzi na podstawie nagłówka żądania 'Origin' nie będzie działać.

Dla wielu domen, w twoim .htaccess:

<IfModule mod_headers.c>
    SetEnvIf Origin "http(s)?://(www\.)?(domain1.example|domain2.example)$" AccessControlAllowOrigin=$0$1
    Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
    Header set Access-Control-Allow-Credentials true
</IfModule>

Dla IIS 7.5 + z zainstalowanym modułem URL Rewrite 2.0 zobacz this so answer

[1]}dla użytkowników Nginx, aby umożliwić CORS dla wielu domen. Podoba mi się przykład @ Marshalla, chociaż jego anwers pasuje Tylko do jednej domeny. Aby dopasować listę domen i subdomen, regex ułatwia pracę z czcionkami:

location ~* \.(?:ttf|ttc|otf|eot|woff|woff2)$ {
   if ( $http_origin ~* (https?://(.+\.)?(domain1|domain2|domain3)\.(?:me|co|com)$) ) {
      add_header "Access-Control-Allow-Origin" "$http_origin";
   }
}

Wyświetli tylko nagłówki "Access-Control-Allow-Origin" pasujące do podanej listy domen.

Oto rozwiązanie dla Java web app, oparte na odpowiedzi od yesthatguy.

Konfiguracja sieci.xml, aby być świadomym Jersey REST i CORSResponseFilter

 <!-- Jersey REST config -->
  <servlet>    
    <servlet-name>JAX-RS Servlet</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param> 
        <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
        <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
      <param-value>com.your.package.CORSResponseFilter</param-value>
    </init-param>   
    <init-param>
        <param-name>com.sun.jersey.config.property.packages</param-name>
        <param-value>com.your.package</param-value>
    </init-param>        
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>

Oto kod do CORSResponseFilter

import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerResponse;
import com.sun.jersey.spi.container.ContainerResponseFilter;


public class CORSResponseFilter implements ContainerResponseFilter{

@Override
public ContainerResponse filter(ContainerRequest request,
        ContainerResponse response) {

    String[] allowDomain = {"http://localhost:9000","https://my.domain.example"};
    Set<String> allowedOrigins = new HashSet<String>(Arrays.asList (allowDomain));                  

    String originHeader = request.getHeaderValue("Origin");

    if(allowedOrigins.contains(originHeader)) {
        response.getHttpHeaders().add("Access-Control-Allow-Origin", originHeader);

        response.getHttpHeaders().add("Access-Control-Allow-Headers",
                "origin, content-type, accept, authorization");
        response.getHttpHeaders().add("Access-Control-Allow-Credentials", "true");
        response.getHttpHeaders().add("Access-Control-Allow-Methods",
                "GET, POST, PUT, DELETE, OPTIONS, HEAD");
    }

    return response;
}

}

Jak wspomniano powyżej, Access-Control-Allow-Origin powinna być unikalna, a Vary powinna być ustawiona na Origin, jeśli jesteś za CDN (Content Delivery Network).

if ($http_origin ~* (https?://.*\.mydomain.example(:[0-9]+)?)) {
  set $cors "true";
}
if ($cors = "true") {
  add_header 'Access-Control-Allow-Origin' "$http_origin";
  add_header 'X-Frame-Options' "ALLOW FROM $http_origin";
  add_header 'Access-Control-Allow-Credentials' 'true';
  add_header 'Vary' 'Origin';
}

Może się mylę, ale z tego co widzę Access-Control-Allow-Origin mA "origin-list" jako parametr.

Przez definicja an origin-list to:

origin            = "origin" ":" 1*WSP [ "null" / origin-list ]
origin-list       = serialized-origin *( 1*WSP serialized-origin )
serialized-origin = scheme "://" host [ ":" port ]
                  ; <scheme>, <host>, <port> productions from RFC3986

I z tego twierdzę, że różne pochodzenie są dopuszczone i powinny być oddzielone przestrzenią.

Z trudem skonfigurowałem to dla domeny z HTTPS, więc pomyślałem, że podzielę się rozwiązaniem. Użyłem następującej dyrektywy w moim httpd.plik conf:

    <FilesMatch "\.(ttf|otf|eot|woff)$">
            SetEnvIf Origin "^http(s)?://(.+\.)?example\.com$" AccessControlAllowOrigin=$0
            Header set Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
    </FilesMatch>

Zmień example.com na nazwę domeny. Dodaj to wewnątrz {[3] } w swoim httpd.plik conf . Zauważ, że jeśli twoja VirtualHost mA przyrostek portu (np. :80), to ta dyrektywa nie będzie miała zastosowania do HTTPS, więc musisz również przejść do / etc / apache2/sites-available / default-ssl i dodać tę samą dyrektywę w tym plik, wewnątrz sekcji <VirtualHost _default_:443>.

Po zaktualizowaniu plików konfiguracyjnych, będziesz musiał uruchomić następujące polecenia w terminalu:

a2enmod headers
sudo service apache2 reload

Jeśli masz problemy z czcionkami, użyj:

<FilesMatch "\.(ttf|ttc|otf|eot|woff)$">
    <IfModule mod_headers>
        Header set Access-Control-Allow-Origin "*"
    </IfModule>
</FilesMatch>

HTTP_ORIGIN nie jest używany przez wszystkie przeglądarki. Jak bezpieczny jest HTTP_ORIGIN? dla mnie wychodzi pusto w FF.
Mam witryny, które pozwalają na dostęp do mojej witryny wysłać przez ID witryny, a następnie sprawdzić mój DB rekord z tym id i uzyskać wartość kolumny SITE_URL (www.yoursite.com).

header('Access-Control-Allow-Origin: http://'.$row['SITE_URL']);

Nawet jeśli wyślij poprawny identyfikator witryny, żądanie musi pochodzić z domeny wymienionej w moim DB powiązanej z tym identyfikatorem witryny.

Oto Rozszerzona opcja dla apache, która zawiera niektóre z najnowszych i planowanych definicji czcionek:

<FilesMatch "\.(ttf|otf|eot|woff|woff2|sfnt|svg)$">
    <IfModule mod_headers.c>
        SetEnvIf Origin "^http(s)?://(.+\.)?(domainname1|domainname2|domainname3)\.(?:com|net|org)$" AccessControlAllowOrigin=$0$1$2
        Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
        Header set Access-Control-Allow-Credentials true
    </IfModule>
</FilesMatch>

I jeszcze jedna odpowiedź w Django. Aby mieć jeden widok Zezwalaj CORS z wielu domen, Oto Mój kod:

def my_view(request):
    if 'HTTP_ORIGIN' in request.META.keys() and request.META['HTTP_ORIGIN'] in ['http://allowed-unsecure-domain.com', 'https://allowed-secure-domain.com', ...]:
        response = my_view_response() # Create your desired response data: JsonResponse, HttpResponse...
        # Then add CORS headers for access from delivery
        response["Access-Control-Allow-Origin"] = request.META['HTTP_ORIGIN']
        response["Access-Control-Allow-Methods"] = "GET" # "GET, POST, PUT, DELETE, OPTIONS, HEAD"
        response["Access-Control-Max-Age"] = "1000"  
        response["Access-Control-Allow-Headers"] = "*"  
        return response

Aby ułatwić dostęp do wielu domen dla usługi ASMX, stworzyłem tę funkcję w global.plik asax:

protected void Application_BeginRequest(object sender, EventArgs e)
{
    string CORSServices = "/account.asmx|/account2.asmx";
    if (CORSServices.IndexOf(HttpContext.Current.Request.Url.AbsolutePath) > -1)
    {
        string allowedDomains = "http://xxx.yyy.example|http://aaa.bbb.example";

        if(allowedDomains.IndexOf(HttpContext.Current.Request.Headers["Origin"]) > -1)
            HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", HttpContext.Current.Request.Headers["Origin"]);

        if(HttpContext.Current.Request.HttpMethod == "OPTIONS")
            HttpContext.Current.Response.End();
    }
}

Pozwala to również na obsługę Kors OPTIONS czasownika.

Odpowiedź Wsparcia Google na wyświetlanie reklam przez SSL i gramatyka w samym RFC wydaje się wskazywać, że możesz ograniczać spacje adresów URL. Nie wiem, jak dobrze jest to obsługiwane w różnych przeglądarkach.

Jeśli spróbujesz tak wielu przykładów kodu, jak ja, aby to działało za pomocą CORS, warto wspomnieć, że musisz wyczyścić pamięć podręczną, aby spróbować, jeśli faktycznie działa, podobnie do problemów, takich jak gdy stare obrazy są nadal obecne, nawet jeśli jest usuwany na serwerze (ponieważ jest nadal zapisany w pamięci podręcznej).

Na przykład CTRL + SHIFT + DEL w Google Chrome, aby usunąć pamięć podręczną.

To pomogło mi używać tego kodu po wypróbowaniu wielu czystych rozwiązań .htaccess i wydawało się to tylko jeden działa (przynajmniej dla mnie):

    Header add Access-Control-Allow-Origin "http://google.com"
    Header add Access-Control-Allow-Headers "authorization, origin, user-token, x-requested-with, content-type"
    Header add Access-Control-Allow-Methods "PUT, GET, POST, DELETE, OPTIONS"

    <FilesMatch "\.(ttf|otf|eot|woff)$">
        <IfModule mod_headers.c>
            SetEnvIf Origin "http(s)?://(www\.)?(google.com|staging.google.com|development.google.com|otherdomain.com|dev02.otherdomain.net)$" AccessControlAllowOrigin=$0
            Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
        </IfModule>
    </FilesMatch>

Zauważ również, że jest szeroko rozpowszechnione, że wiele rozwiązań mówi, że musisz wpisać Header set ..., ale jest to Header add .... Mam nadzieję, że to pomoże komuś, kto ma takie same problemy przez kilka godzin, jak ja.

Dla dość łatwego kopiowania / wklejania dla aplikacji. NET, napisałem to, aby włączyć CORS z poziomu globalnego.plik asax. Kod ten jest zgodny z poradą udzieloną w aktualnie akceptowanej odpowiedzi, odzwierciedlając to, jakie pochodzenie jest podane we wniosku do odpowiedzi. To skutecznie osiąga " * " bez użycia go. Powodem tego jest to, że umożliwia wiele innych funkcji CORS, w tym możliwość wysłania zapytania AJAX XMLHttpRequest z atrybutem 'withCredentials' ustawionym na "prawda".

void Application_BeginRequest(object sender, EventArgs e)
{
    if (Request.HttpMethod == "OPTIONS")
    {
        Response.AddHeader("Access-Control-Allow-Methods", "GET, POST");
        Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
        Response.AddHeader("Access-Control-Max-Age", "1728000");
        Response.End();
    }
    else
    {
        Response.AddHeader("Access-Control-Allow-Credentials", "true");

        if (Request.Headers["Origin"] != null)
            Response.AddHeader("Access-Control-Allow-Origin" , Request.Headers["Origin"]);
        else
            Response.AddHeader("Access-Control-Allow-Origin" , "*");
    }
}

Bardziej elastycznym podejściem jest użycie wyrażeń Apache 2.4. Możesz dopasować domeny, ścieżki i prawie każdą inną zmienną żądania. Chociaż odpowiedź jest * dla wszystkich, jedynymi żądającymi otrzymującymi tę odpowiedź są ci, którzy i tak spełniają wymagania.

<IfModule mod_headers.c>
    <If "%{HTTP:Host} =~ /\\byourdomain\\.example$/i">
        Header set Access-Control-Allow-Origin "*"
    </If>
</IfModule>

Przykład kodu PHP do dopasowania subdomen.

if( preg_match("/http:\/\/(.*?)\.yourdomain.example/", $_SERVER['HTTP_ORIGIN'], $matches )) {
        $theMatch = $matches[0];
        header('Access-Control-Allow-Origin: ' . $theMatch);
}

Odpowiedzią wydaje się być użycie nagłówka więcej niż raz. Czyli zamiast wysyłać

Access-Control-Allow-Origin: http://domain1.example, http://domain2.example, http://domain3.example

Wyślij

Access-Control-Allow-Origin: http://domain1.example
Access-Control-Allow-Origin: http://domain2.example
Access-Control-Allow-Origin: http://domain3.example

Na Apache, można to zrobić w httpd.conf <VirtualHost> section or .htaccess file using mod_headers and this syntax:

Header add Access-Control-Allow-Origin "http://domain1.example"
Header add Access-Control-Allow-Origin "http://domain2.example"
Header add Access-Control-Allow-Origin "http://domain3.example"

Sztuką jest użycie add zamiast append jako pierwszego argumentu.

Możemy również ustawić to w trybie globalnym.plik asax dla Asp.net podanie.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

    // enable CORS
    HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "https://www.youtube.com");

    }