Zugriffssteuerung-Zulassen-Ursprung Mehrere Ursprungsdomänen?

Gibt es eine Möglichkeit, mehrere domänenübergreifende Funktionen mithilfe des Access-Control-Allow-OriginHeaders zuzulassen ?

Ich bin mir dessen bewusst *, aber es ist zu offen. Ich möchte wirklich nur ein paar Domains zulassen.

Zum Beispiel so etwas:

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

Ich habe den obigen Code ausprobiert, aber er scheint in Firefox nicht zu funktionieren.

Ist es möglich, mehrere Domains anzugeben, oder stecke ich nur bei einer fest?

Klingt so, als würde empfohlen, dass Ihr Server den Origin-Header vom Client liest, diesen mit der Liste der Domänen vergleicht, die Sie zulassen möchten, und wenn dies übereinstimmt, den Wert des OriginHeaders an den Client zurücksendet der Access-Control-Allow-OriginHeader in der Antwort.

Mit .htaccesskönnen Sie es so machen:

# ----------------------------------------------------------------------
# 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>

Eine andere Lösung, die ich in PHP verwende:

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

Das hat bei mir funktioniert:

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

Wenn .htaccesses eingesetzt wird, wird es sicher funktionieren.

Ich hatte das gleiche Problem mit Woff-Schriften, mehrere Subdomains mussten Zugriff haben. Um Subdomains zuzulassen, habe ich meiner httpd.conf Folgendes hinzugefügt:

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>

Für mehrere Domains können Sie einfach den regulären Ausdruck in ändern SetEnvIf.

Hier erfahren Sie, wie Sie den Origin-Header wiedergeben, wenn er mit Ihrer Domain mit Nginx übereinstimmt. Dies ist nützlich, wenn Sie eine Schriftart für mehrere Subdomains bereitstellen möchten:

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

Folgendes habe ich für eine PHP-Anwendung getan, die von AJAX angefordert wird

$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);
}

Wenn der anfordernde Ursprung von meinem Server zugelassen wird, geben Sie sich $http_originselbst als Wert des Access-Control-Allow-OriginHeaders zurück, anstatt einen *Platzhalter zurückzugeben.

Es gibt einen Nachteil, den Sie beachten sollten: Sobald Sie Dateien an ein CDN (oder einen anderen Server, der keine Skripterstellung zulässt) auslagern oder wenn Ihre Dateien auf einem Proxy zwischengespeichert werden, ändern Sie die Antwort basierend auf "Origin". Anforderungsheader funktioniert nicht.

Für mehrere Domains in Ihrem .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>

Für Nginx-Benutzer, CORS für mehrere Domänen zuzulassen. Ich mag das Beispiel von @ marshall, obwohl seine Antworten nur einer Domain entsprechen. Um eine Liste von Domänen und Unterdomänen abzugleichen, erleichtert diese Regex die Arbeit mit Schriftarten:

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";
   }
}

Dies gibt nur "Access-Control-Allow-Origin" -Header wieder, die mit der angegebenen Liste von Domains übereinstimmen.

Informationen zu IIS 7.5+ mit installiertem URL Rewrite 2.0-Modul finden Sie in dieser SO-Antwort

Hier ist eine Lösung für die Java-Web-App, basierend auf der Antwort von yesthatguy.

Ich benutze Jersey REST 1.x.

Konfigurieren Sie die Datei web.xml so, dass Jersey REST und CORSResponseFilter bekannt sind

 <!-- 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>

Hier ist der Code für 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;
}

}

Wie oben erwähnt, Access-Control-Allow-Originsollte eindeutig sein und Varyauf eingestellt werden, Originwenn Sie sich hinter einem CDN (Content Delivery Network) befinden.

Relevanter Teil meiner Nginx-Konfiguration:

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';
}

Vielleicht irre ich mich, aber soweit ich sehen kann Access-Control-Allow-Originhat ein "origin-list"as Parameter.

Durch die Definition eines origin-listist:

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

Und daraus argumentiere ich, dass unterschiedliche Ursprünge zugelassen sind und räumlich getrennt sein sollten .

Für ExpressJS-Anwendungen können Sie Folgendes verwenden:

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();
});

Ich hatte Mühe, dies für eine Domain einzurichten, auf der HTTPS ausgeführt wird, und dachte mir, ich würde die Lösung gemeinsam nutzen. Ich habe die folgende Anweisung in meiner httpd.conf- Datei verwendet:

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

Ändern Sie example.comIhren Domainnamen. Fügen Sie dies <VirtualHost x.x.x.x:xx>in Ihre httpd.conf- Datei ein. Beachten Sie, dass diese Anweisung nicht für HTTPS gilt , wenn Sie VirtualHostein Port-Suffix haben (z. B. :80). Sie müssen daher auch zu / etc / apache2 / sites-available / default-ssl gehen und dieselbe Anweisung in diese Datei einfügen des <VirtualHost _default_:443>Abschnitts.

Sobald die Konfigurationsdateien aktualisiert wurden, müssen Sie die folgenden Befehle im Terminal ausführen:

a2enmod headers
sudo service apache2 reload

Wenn Sie Probleme mit Schriftarten haben, verwenden Sie:

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

Ein flexiblerer Ansatz ist die Verwendung der Ausdrücke von Apache 2.4. Sie können mit Domänen, Pfaden und nahezu jeder anderen Anforderungsvariablen übereinstimmen. Obwohl die gesendete Antwort immer ist *, sind die einzigen Anforderer, die sie erhalten, diejenigen, die die Anforderungen trotzdem erfüllen. Die Verwendung des Origin(oder eines anderen) Anforderungsheaders im Ausdruck führt dazu, dass Apache ihn automatisch in den VaryAntwortheader einfügt, sodass die Antwort nicht für einen anderen Ursprung wiederverwendet wird.

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

PHP-Code:

$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');

HTTP_ORIGIN wird nicht von allen Browsern verwendet. Wie sicher ist HTTP_ORIGIN? Für mich ist es in FF leer.
Ich habe die Sites, denen ich den Zugriff auf meine Site erlaube, über eine Site-ID gesendet. Anschließend überprüfe ich meine Datenbank auf den Datensatz mit dieser ID und erhalte den Spaltenwert SITE_URL (www.yoursite.com).

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

Selbst wenn eine gültige Site-ID gesendet wird, muss die Anforderung von der Domäne stammen, die in meiner mit dieser Site-ID verknüpften Datenbank aufgeführt ist.

Hier ist eine erweiterte Option für Apache, die einige der neuesten und geplanten Schriftartdefinitionen enthält:

<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>

Um den Zugriff auf mehrere Domänen für einen ASMX-Dienst zu erleichtern, habe ich diese Funktion in der Datei global.asax erstellt:

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();
    }
}

Dies ermöglicht auch die CORS-Behandlung von OPTIONSVerben.

PHP-Codebeispiel für übereinstimmende Subdomains.

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

Für ein relativ einfaches Kopieren / Einfügen für .NET-Anwendungen habe ich dies geschrieben, um CORS aus einer global.asaxDatei heraus zu aktivieren . Dieser Code folgt den Ratschlägen in der aktuell akzeptierten Antwort und spiegelt den Ursprung wider, der in der Anfrage in der Antwort angegeben ist. Dies erreicht effektiv '*', ohne es zu verwenden.

Der Grund dafür ist, dass mehrere andere CORS-Funktionen aktiviert werden, einschließlich der Möglichkeit, eine AJAX XMLHttpRequest mit dem Attribut 'withCredentials' auf 'true' zu senden.

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

Und noch eine Antwort in Django. Damit eine einzelne Ansicht CORS aus mehreren Domänen zulässt, ist hier mein Code:

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

Informationen zum Konfigurieren mehrerer Ursprünge auf Serverless AWS Lambda und API Gateway finden Sie hier: Eine ziemlich umfangreiche Lösung für etwas, das Ihrer Meinung nach recht einfach sein sollte:

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

Es ist derzeit nicht möglich, mehrere Ursprünge in API Gateway zu konfigurieren, siehe hier: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), aber die Empfehlung (in Die Antwort oben lautet:

• Überprüfen Sie den vom Browser gesendeten Origin-Header
• Überprüfen Sie es anhand einer Whitelist der Herkunft
• Wenn dies übereinstimmt, geben Sie den eingehenden Origin als Header für Access-Control-Allow-Origin zurück. Andernfalls geben Sie einen Platzhalter zurück (Standardursprung).

Die einfache Lösung besteht offensichtlich darin, ALL (*) wie folgt zu aktivieren:

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([{

Es ist jedoch möglicherweise besser, dies auf der API-Gateway-Seite zu tun (siehe 2. Link oben).

Die Antwort von Google auf die Schaltung von Anzeigen über SSL und die Grammatik im RFC selbst scheinen darauf hinzudeuten, dass Sie die URLs durch Leerzeichen begrenzen können. Ich bin mir nicht sicher, wie gut dies in verschiedenen Browsern unterstützt wird.

Wenn Sie so viele Codebeispiele wie mich ausprobieren, damit es mit CORS funktioniert, müssen Sie zuerst Ihren Cache leeren, um zu versuchen, ob es tatsächlich funktioniert, ähnlich wie bei Problemen, wenn alte Bilder noch vorhanden sind, auch wenn dies der Fall ist auf dem Server gelöscht (weil es noch in Ihrem Cache gespeichert ist).

Zum Beispiel CTRL + SHIFT + DELin Google Chrome, um Ihren Cache zu löschen.

Dies hat mir geholfen, diesen Code zu verwenden, nachdem ich viele reine .htaccessLösungen ausprobiert hatte , und dies schien die einzige zu sein, die funktionierte (zumindest für mich):

    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>

Beachten Sie auch, dass es weit verbreitet ist, dass viele Lösungen sagen, dass Sie tippen müssen, Header set ...aber es ist Header add .... Ich hoffe, das hilft jemandem, der seit einigen Stunden die gleichen Probleme hat wie ich.

Die folgende Antwort ist spezifisch für C #, das Konzept sollte jedoch auf alle verschiedenen Plattformen anwendbar sein.

Um Cross Origin-Anforderungen von einer Web-API aus zuzulassen, müssen Sie Optionsanfragen für Ihre Anwendung zulassen und auf Controller-Ebene die folgenden Anmerkungen hinzufügen.

[EnableCors (UrlString, Header, Method)] Jetzt können die Ursprünge nur noch als Zeichenfolge übergeben werden. Wenn Sie also mehr als eine URL in der Anforderung übergeben möchten, übergeben Sie diese als durch Kommas getrennten Wert.

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

Für den Header Access-Control-Allow-Origin kann nur ein einziger Ursprung angegeben werden. Sie können den Ursprung in Ihrer Antwort jedoch entsprechend der Anforderung festlegen. Vergessen Sie auch nicht, den Vary-Header festzulegen. In PHP würde ich Folgendes tun:

    /**
     * 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
  }

Wir können dies auch in der Datei Global.asax für die Asp.net-Anwendung festlegen.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

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

    }