Access-Control-Allow-Origin Domini di origine multipli?

Esiste un modo per consentire più domini diversi usando l' Access-Control-Allow-Originintestazione?

Ne sono consapevole *, ma è troppo aperto. Voglio davvero consentire solo un paio di domini.

Ad esempio, qualcosa del genere:

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

Ho provato il codice sopra ma non sembra funzionare in Firefox.

È possibile specificare più domini o sono bloccato con uno solo?

Sembra che il modo consigliato per farlo sia fare in modo che il tuo server legga l'intestazione Origin dal client, confrontalo con l'elenco dei domini che desideri consentire e, se corrisponde, fai eco al valore Origindell'intestazione sul client come l' Access-Control-Allow-Originintestazione nella risposta.

Con .htaccesste puoi farlo in questo modo:

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

Un'altra soluzione che sto usando in 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");
}

Questo ha funzionato per me:

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

Una volta inserito .htaccess, funzionerà sicuramente.

Ho avuto lo stesso problema con i caratteri woff, a più sottodomini doveva essere consentito l'accesso. Per consentire i sottodomini ho aggiunto qualcosa di simile al mio 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>

Per più domini potresti semplicemente cambiare la regex in SetEnvIf.

Ecco come riecheggiare l'intestazione Origin se corrisponde al tuo dominio con Nginx, questo è utile se vuoi servire un carattere su più sottodomini:

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

Ecco cosa ho fatto per un'applicazione PHP che è stata richiesta da 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);
}

Se l'origine richiedente è consentita dal mio server, restituisce $http_originse stesso come valore Access-Control-Allow-Origindell'intestazione anziché restituire un *carattere jolly.

C'è uno svantaggio di cui dovresti essere a conoscenza: non appena esegui l'outsourcing dei file su un CDN (o qualsiasi altro server che non consente lo scripting) o se i tuoi file vengono memorizzati nella cache su un proxy, alterando la risposta in base a "Origine" l'intestazione della richiesta non funzionerà.

Per più domini, nel tuo .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>

Per gli utenti di Nginx consentire CORS per più domini. Mi piace l'esempio di @ marshall anche se le sue risposte corrispondono solo a un dominio. Per abbinare un elenco di domini e sottodomini questo regex semplifica il lavoro con i caratteri:

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

Ciò farà eco solo alle intestazioni "Access-Control-Allow-Origin" che corrispondono all'elenco di domini specificato.

Per IIS 7.5+ con il modulo URL Rewrite 2.0 installato, vedere questa risposta SO

Ecco una soluzione per l'app Web Java, basata sulla risposta di yesthatguy.

Sto usando Jersey REST 1.x

Configurare web.xml per essere a conoscenza di Jersey REST e 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>

Ecco il codice per 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;
}

}

Come accennato in precedenza, Access-Control-Allow-Origindovrebbe essere univoco e Varydovrebbe essere impostato su Originse si è dietro un CDN (Content Delivery Network).

Parte rilevante della mia configurazione 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';
}

Forse mi sbaglio, ma per quanto posso vedere Access-Control-Allow-Originha un "origin-list"parametro as.

Per definizione an origin-listè:

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

E da questo, sostengo che sono ammesse origini diverse e dovrebbero essere separate dallo spazio .

Per le applicazioni ExpressJS è possibile utilizzare:

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

Ho faticato a configurarlo per un dominio che esegue HTTPS, quindi ho pensato di condividere la soluzione. Ho usato la seguente direttiva nel mio file httpd.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>

Passa example.comal tuo nome di dominio. Aggiungi questo all'interno <VirtualHost x.x.x.x:xx>nel tuo file httpd.conf . Nota che se hai VirtualHostun suffisso (ad es. :80), Questa direttiva non si applicherà a HTTPS, quindi dovrai anche andare su / etc / apache2 / sites-available / default-ssl e aggiungere la stessa direttiva in quel file, all'interno della <VirtualHost _default_:443>sezione.

Dopo aver aggiornato i file di configurazione, è necessario eseguire i seguenti comandi nel terminale:

a2enmod headers
sudo service apache2 reload

In caso di problemi con i caratteri, utilizzare:

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

Un approccio più flessibile consiste nell'utilizzare le espressioni di Apache 2.4. Puoi abbinare domini, percorsi e praticamente ogni altra variabile di richiesta. Sebbene la risposta inviata sia sempre *, gli unici richiedenti che la ricevono sono comunque quelli che soddisfano i requisiti. L'uso dell'intestazione della richiesta Origin(o di qualsiasi altra) nell'espressione fa sì che Apache la fonda automaticamente nell'intestazione della Varyrisposta, in modo che la risposta non venga riutilizzata per un'origine diversa.

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

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

HTTP_ORIGIN non è utilizzato da tutti i browser. Quanto è sicuro HTTP_ORIGIN? Per me risulta vuoto in FF.
Ho i siti a cui autorizzo l'accesso al mio sito tramite un ID sito, quindi controllo il mio DB per il record con quell'ID e ottengo il valore della colonna SITE_URL (www.tuoSite.com).

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

Anche se l'invio su un ID sito valido, la richiesta deve provenire dal dominio elencato nel mio DB associato a tale ID sito.

Ecco un'opzione estesa per apache che include alcune delle definizioni dei font più recenti e pianificate:

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

Per facilitare l'accesso a più domini per un servizio ASMX, ho creato questa funzione nel file 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();
    }
}

Ciò consente anche la gestione CORS del OPTIONSverbo.

Esempio di codice PHP per la corrispondenza dei sottodomini.

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

Per una copia / incolla abbastanza semplice per le applicazioni .NET, ho scritto questo per abilitare CORS dall'interno di un global.asaxfile. Questo codice segue i consigli forniti nella risposta attualmente accettata, riflettendo nella risposta qualsiasi origine restituita nella richiesta. Ciò raggiunge effettivamente '*' senza usarlo.

La ragione di ciò è che abilita molteplici altre funzionalità CORS , inclusa la possibilità di inviare un AJAX XMLHttpRequest con l'attributo 'withCredentials' impostato su '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" , "*");
    }
}

E un'altra risposta in Django. Per avere una vista singola consentire CORS da più domini, ecco il mio codice:

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

Per informazioni su come configurare origini multiple su Serverless AWS Lambda e API Gateway - anche se una soluzione piuttosto grande per qualcosa che si potrebbe pensare dovrebbe essere abbastanza semplice - vedi qui:

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

Al momento non è possibile configurare origini multiple in API Gateway, vedere qui: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), ma la raccomandazione (in la risposta sopra) è:

• ispeziona l'intestazione Origin inviata dal browser
• verificalo con una whitelist di origini
• se corrisponde, restituisce Origin in arrivo come intestazione Access-Control-Allow-Origin, altrimenti restituisce un segnaposto (origine predefinita).

La semplice soluzione sta ovviamente abilitando ALL (*) in questo modo:

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

Ma potrebbe essere meglio farlo sul lato API Gateway (vedi 2 ° link sopra).

La risposta dell'assistenza di Google sulla pubblicazione di annunci su SSL e la grammatica nella stessa RFC sembrerebbe indicare che è possibile delimitare lo spazio degli URL. Non sono sicuro di quanto sia ben supportato questo nei diversi browser.

Se provi così tanti esempi di codice come me per farlo funzionare usando CORS, vale la pena ricordare che devi prima svuotare la cache per provare se funziona davvero, simile a problemi come quando le vecchie immagini sono ancora presenti, anche se è cancellato sul server (perché è ancora salvato nella cache).

Ad esempio CTRL + SHIFT + DELin Google Chrome per eliminare la cache.

Questo mi ha aiutato a usare questo codice dopo aver provato molte .htaccesssoluzioni pure e questo sembrava l'unico funzionante (almeno per me):

    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>

Si noti inoltre che è ampiamente diffuso che molte soluzioni affermano che è necessario digitare, Header set ...ma lo è Header add .... Spero che questo aiuti qualcuno che ha gli stessi problemi per alcune ore come me.

La risposta di seguito è specifica per C #, ma il concetto dovrebbe essere applicabile a tutte le diverse piattaforme.

Per consentire le richieste di origine incrociata da un'API Web, è necessario consentire le richieste di opzione all'applicazione e aggiungere l'annotazione di seguito a livello di controller.

[EnableCors (UrlString, Header, Method)] Ora le origini possono essere passate solo come stringa. Quindi, se si desidera passare più di un URL nella richiesta, passarlo come valore separato da virgola.

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

È possibile specificare una sola origine per l'intestazione Access-Control-Allow-Origin. Ma puoi impostare l'origine nella tua risposta in base alla richiesta. Inoltre, non dimenticare di impostare l'intestazione Vary. In PHP farei quanto segue:

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

Possiamo anche impostarlo nel file Global.asax per l'applicazione Asp.net.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

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

    }