Kontrola dostępu-Allow-Origin Domeny wielu źródeł?

Czy istnieje sposób na zezwolenie na wiele domen w wielu domenach za pomocą Access-Control-Allow-Originnagłówka?

Jestem tego świadomy *, ale jest zbyt otwarty. Naprawdę chcę pozwolić tylko na kilka domen.

Na przykład coś takiego:

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

Próbowałem powyższego kodu, ale wydaje się, że nie działa on w przeglądarce Firefox.

Czy można podać wiele domen, czy utknąłem tylko z jedną?

Wygląda na to, że zalecanym sposobem jest, aby Twój serwer odczytał nagłówek Origin od klienta, porównaj to z listą domen, na które chcesz zezwolić, a jeśli to pasuje, wyświetl wartość Originnagłówka z powrotem do klienta jako Access-Control-Allow-Originnagłówek w odpowiedzi.

Z .htaccesswas może zrobić to tak:

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

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 działało dla mnie:

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 włożeniu na .htaccesspewno będzie działać.

Miałem ten sam problem z czcionkami woff, wiele subdomen musiało mieć dostęp. Aby zezwolić na poddomeny, 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>

W przypadku wielu domen możesz po prostu zmienić wyrażenie regularne SetEnvIf.

Oto jak ponownie wyświetlić nagłówek Origin, jeśli pasuje on do Twojej domeny z Nginx, jest to przydatne, jeśli chcesz wyświetlać czcionkę w wielu subdomenach:

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 żądający początek jest dozwolony przez mój serwer, zwróć go $http_originjako wartość Access-Control-Allow-Originnagłówka zamiast zwracać *symbol wieloznaczny.

Jest jedna wada, o której powinieneś wiedzieć: jak tylko prześlesz pliki na zewnątrz CDN (lub innemu serwerowi, który nie zezwala na skrypty) lub jeśli twoje pliki są buforowane na serwerze proxy, zmiana odpowiedzi na podstawie „Origin” nagłówek żądania nie będzie działać.

W przypadku wielu domen w .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>

Użytkownicy Nginx zezwalają na CORS dla wielu domen. Podoba mi się przykład @ marshalla, chociaż jego odpowiedzi odpowiadają tylko jednej domenie. Aby dopasować listę domen i subdomen, to wyrażenie regularne 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";
   }
}

Spowoduje to echo tylko nagłówków „Access-Control-Allow-Origin”, które pasują do podanej listy domen.

W przypadku IIS 7.5+ z zainstalowanym modułem URL Rewrite 2.0 zobacz tę SO odpowiedź

Oto rozwiązanie dla aplikacji internetowej Java, oparte na odpowiedzi yesthatguy.

Korzystam z Jersey REST 1.x

Skonfiguruj plik web.xml, aby był świadomy 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 dla 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-Originpowinno być unikalne i Varypowinno być ustawione naOrigin jeśli jesteś za CDN (Content Delivery Network).

Odpowiednia część mojej konfiguracji Nginx:

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 o ile widzę Access-Control-Allow-Originma"origin-list" parametr as.

Z definicji an origin-listto:

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 źródła są akceptowane i powinny być oddzielone przestrzenią .

Do aplikacji ExpressJS możesz użyć:

app.use((req, res, next) => {
    const corsWhitelist = [
        'https://domain1.example',
        'https://domain2.example',
        'https://domain3.example'
    ];
    if (corsWhitelist.indexOf(req.headers.origin) !== -1) {
        res.header('Access-Control-Allow-Origin', req.headers.origin);
        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
    }

    next();
});

Próbowałem to skonfigurować dla domeny z HTTPS, więc pomyślałem, że podzielę się tym rozwiązaniem. W pliku httpd.conf zastosowałem następującą dyrektywę :

    <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.comnazwę swojej domeny. Dodaj to do <VirtualHost x.x.x.x:xx>swojego pliku httpd.conf . Zauważ, że jeśli masz VirtualHostsufiks portu (np. :80), To ta dyrektywa nie będzie miała zastosowania do HTTPS, więc musisz także przejść do / etc / apache2 / sites-available / default-ssl i dodać tę samą dyrektywę do tego pliku, wewnątrz z<VirtualHost _default_:443> sekcji.

Po zaktualizowaniu plików konfiguracyjnych należy 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>

Bardziej elastycznym podejściem jest użycie wyrażeń Apache 2.4. Możesz dopasować do domen, ścieżek i niemal każdej innej zmiennej żądania. Chociaż odpowiedź jest zawsze wysyłana *, jedynymi osobami, które ją odbierają, i tak spełniają te wymagania. Użycie Originnagłówka żądania (lub dowolnego innego) w wyrażeniu powoduje, że Apache automatycznie łączy je z Varynagłówkiem odpowiedzi, dzięki czemu odpowiedź nie będzie ponownie używana dla innego źródła.

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

HTTP_ORIGIN nie jest używany przez wszystkie przeglądarki. Jak bezpieczny jest HTTP_ORIGIN? Dla mnie jest pusta w FF.
Witryny, które zezwalam na dostęp do mojej witryny, przesyłam za pomocą identyfikatora witryny, a następnie sprawdzam, czy w mojej bazie danych nie ma rekordu o tym identyfikatorze, i otrzymuję wartość kolumny SITE_URL (www.yoursite.com).

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

Nawet jeśli przesłano prawidłowy identyfikator witryny, żądanie musi pochodzić z domeny wymienionej w mojej bazie danych powiązanej z tym identyfikatorem witryny.

Oto rozszerzona opcja 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>

Aby ułatwić dostęp do wielu domen dla usługi ASMX, utworzyłem tę funkcję w pliku global.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ę OPTIONSczasownika przez CORS .

Przykład kodu PHP dla pasujących subdomen.

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

Dla dość łatwego kopiowania / wklejania dla aplikacji .NET napisałem to, aby włączyć CORS z global.asaxpliku. Ten kod jest zgodny z radą podaną w obecnie akceptowanej odpowiedzi, odzwierciedlając pochodzenie podane w zapytaniu w odpowiedzi. To skutecznie osiąga „*” bez użycia.

Powodem tego jest to, że umożliwia wiele innych funkcji CORS , w tym możliwość wysyłania AJAX XMLHttpRequest z atrybutem „withCredentials” ustawionym na „true”.

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" , "*");
    }
}

Kod PHP:

$httpOrigin = isset($_SERVER['HTTP_ORIGIN']) ? $_SERVER['HTTP_ORIGIN'] : null;
if (in_array($httpOrigin, [
    'http://localhost:9000', // Co-worker dev-server
    'http://127.0.0.1:9001', // My dev-server
])) header("Access-Control-Allow-Origin: ${httpOrigin}");
header('Access-Control-Allow-Credentials: true');

I jeszcze jedna odpowiedź w Django. Aby jeden widok zezwalał na 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

AWS Lambda / API Gateway

Aby uzyskać informacje na temat konfigurowania wielu źródeł w bezserwerowej AWS Lambda i API Gateway - aczkolwiek dość duże rozwiązanie dla czegoś, co mogłoby się wydawać, powinno być dość proste - zobacz tutaj:

https://stackoverflow.com/a/41708323/1624933

Obecnie nie można skonfigurować wielu źródeł w API Gateway, patrz tutaj: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), ale zalecenie (w odpowiedź powyżej) brzmi:

• sprawdź nagłówek Origin wysłany przez przeglądarkę
• sprawdź to na białej liście pochodzenia
• jeśli pasuje, zwróć przychodzące źródło jako nagłówek Access-Control-Allow-Origin, w przeciwnym razie zwróć symbol zastępczy (domyślny początek).

Proste rozwiązanie oczywiście umożliwia WSZYSTKIE (*) w następujący sposób:

exports.handler = async (event) => {
    const response = {
        statusCode: 200,
        headers: {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Credentials" : true // Required for cookies, authorization headers with HTTPS
        },
        body: JSON.stringify([{

Ale może być lepiej zrobić to po stronie API Gateway (patrz 2. link powyżej).

Odpowiedź Google na wsparcie w wyświetlaniu reklam za pośrednictwem protokołu SSL i gramatyka w samym RFC wydaje się wskazywać, że możesz spować adresy URL. Nie jestem pewien, jak dobrze jest to obsługiwane w różnych przeglądarkach.

Jeśli spróbujesz użyć tak wielu przykładów kodu, jak ja, aby działało przy użyciu CORS, warto wspomnieć, że musisz najpierw wyczyścić pamięć podręczną, aby sprawdzić, czy rzeczywiście działa, podobnie jak w przypadku, gdy stare obrazy są nadal obecne, nawet jeśli są usunięty na serwerze (ponieważ nadal jest zapisany w pamięci podręcznej).

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

Pomogło mi to użyć tego kodu po wypróbowaniu wielu czystych .htaccessrozwiązań i wydawało mi się, że to jedyne działające (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 pisać, Header set ...ale tak jest Header add .... Mam nadzieję, że to pomaga komuś, kto ma takie same problemy od kilku godzin, jak ja.

Poniższa odpowiedź jest specyficzna dla C #, ale koncepcja powinna mieć zastosowanie do wszystkich różnych platform.

Aby zezwolić na Żądanie krzyżowego pochodzenia z interfejsu internetowego, musisz zezwolić na Żądania opcji do swojej aplikacji i dodać poniżej adnotację na poziomie kontrolera.

[EnableCors (UrlString, Header, Method)] Teraz początki mogą być przekazywane tylko jako ciąg. SO, jeśli chcesz przekazać więcej niż jeden adres URL w żądaniu, podaj go jako wartość oddzieloną przecinkami.

UrlString = " https: //a.hello.com,https: //b.hello.com "

W nagłówku Access-Control-Allow-Origin można określić tylko jedno źródło. Ale możesz ustawić pochodzenie w swojej odpowiedzi zgodnie z żądaniem. Nie zapomnij także ustawić nagłówka Vary. W PHP zrobiłbym następujące czynności:

    /**
     * Enable CORS for the passed origins.
     * Adds the Access-Control-Allow-Origin header to the response with the origin that matched the one in the request.
     * @param array $origins
     * @return string|null returns the matched origin or null
     */
    function allowOrigins($origins)
    {
        $val = $_SERVER['HTTP_ORIGIN'] ?? null;
        if (in_array($val, $origins, true)) {
            header('Access-Control-Allow-Origin: '.$val);
            header('Vary: Origin');

            return $val;
        }

        return null;
    }

  if (allowOrigins(['http://localhost', 'https://localhost'])) {
      echo your response here, e.g. token
  }

Możemy to również ustawić w pliku Global.asax dla aplikacji Asp.net.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

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

    }