Access-Control-Allow-Origin Domaines d'origine multiples?

Existe-t-il un moyen d'autoriser plusieurs domaines croisés à l'aide de l'en- Access-Control-Allow-Origintête?

Je connais le *, mais c'est trop ouvert. Je veux vraiment autoriser seulement quelques domaines.

Par exemple, quelque chose comme ceci:

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

J'ai essayé le code ci-dessus mais il ne semble pas fonctionner dans Firefox.

Est-il possible de spécifier plusieurs domaines ou suis-je coincé avec un seul?

Cela ressemble à la façon recommandée de le faire est de demander à votre serveur de lire l'en-tête Origin du client, de le comparer à la liste des domaines que vous souhaitez autoriser, et s'il correspond, de Originrenvoyer la valeur de l'en- tête au client sous la forme l'en- Access-Control-Allow-Origintête dans la réponse.

Avec .htaccessvous pouvez le faire comme ceci:

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

Une autre solution que j'utilise en 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");
}

Cela a fonctionné pour moi:

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

Une fois installé .htaccess, cela fonctionnera à coup sûr.

J'ai eu le même problème avec les polices woff, plusieurs sous-domaines devaient y avoir accès. Pour autoriser les sous-domaines, j'ai ajouté quelque chose comme ça à mon 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>

Pour plusieurs domaines, vous pouvez simplement modifier l'expression régulière dans SetEnvIf .

Voici comment renvoyer l'en-tête Origin s'il correspond à votre domaine avec Nginx, cela est utile si vous souhaitez servir une police à plusieurs sous-domaines:

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

Voici ce que j'ai fait pour une application PHP demandée par 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);
}

Si l'origine de la demande est autorisée par mon serveur, retournez le $http_originlui - même comme valeur de l'en- Access-Control-Allow-Origintête au lieu de renvoyer un *caractère générique.

Il y a un inconvénient dont vous devez être conscient: dès que vous externalisez des fichiers vers un CDN (ou tout autre serveur qui n'autorise pas les scripts) ou si vos fichiers sont mis en cache sur un proxy, la modification de la réponse en fonction de 'Origin' l'en-tête de la demande ne fonctionnera pas.

Pour plusieurs domaines, dans votre .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>

Pour que les utilisateurs de Nginx autorisent CORS pour plusieurs domaines. J'aime l'exemple de @ marshall bien que ses réponses ne correspondent qu'à un seul domaine. Pour faire correspondre une liste de domaines et de sous-domaines, cette expression régulière facilite le travail avec les polices:

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

Cela ne fera écho qu'aux en-têtes "Access-Control-Allow-Origin" qui correspondent à la liste de domaines donnée.

Pour IIS 7.5+ avec le module URL Rewrite 2.0 installé, veuillez consulter cette réponse SO

Voici une solution pour l'application Web Java, basée sur la réponse de yesthatguy.

J'utilise Jersey REST 1.x

Configurez le web.xml pour connaître Jersey REST et 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>

Voici le code de 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;
}

}

Comme mentionné ci-dessus, Access-Control-Allow-Origindoit être unique et Varydoit être défini sur Originsi vous êtes derrière un CDN (Content Delivery Network).

Partie pertinente de ma configuration 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';
}

Peut-être que je me trompe, mais autant que je puisse voir Access-Control-Allow-Origina un "origin-list"paramètre as.

Par définition, an origin-listest:

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

Et d'après cela, je soutiens que différentes origines sont admises et devraient être séparées par des espaces .

Pour les applications ExpressJS, vous pouvez utiliser:

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

J'ai eu du mal à configurer cela pour un domaine exécutant HTTPS, alors j'ai pensé que je partagerais la solution. J'ai utilisé la directive suivante dans mon fichier 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>

Changez example.compour votre nom de domaine. Ajoutez-le à l'intérieur <VirtualHost x.x.x.x:xx>de votre fichier httpd.conf . Notez que si vous avez VirtualHostun suffixe de port (par exemple :80), cette directive ne s'appliquera pas à HTTPS, vous devrez donc également aller dans / etc / apache2 / sites-available / default-ssl et ajouter la même directive dans ce fichier, à l'intérieur du<VirtualHost _default_:443> section.

Une fois les fichiers de configuration mis à jour, vous devrez exécuter les commandes suivantes dans le terminal:

a2enmod headers
sudo service apache2 reload

Si vous rencontrez des problèmes avec les polices, utilisez:

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

Une approche plus flexible consiste à utiliser les expressions d'Apache 2.4. Vous pouvez faire correspondre des domaines, des chemins et à peu près toutes les autres variables de demande. Bien que la réponse envoyée soit toujours *, les seuls demandeurs qui la reçoivent sont de toute façon ceux qui répondent aux exigences. L'utilisation de l' Originen-tête de demande (ou de tout autre) dans l'expression entraîne la fusion automatique d'Apache dans l'en- Varytête de réponse, afin que la réponse ne soit pas réutilisée pour une origine différente.

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

Code 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 n'est pas utilisé par tous les navigateurs. HTTP_ORIGIN est-il sécurisé? Pour moi ça revient vide en FF.
J'ai les sites auxquels j'autorise l'accès à mon site envoyer un ID de site, je vérifie ensuite ma base de données pour l'enregistrement avec cet ID et obtenir la valeur de la colonne SITE_URL (www.votresite.com).

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

Même si l'envoi via un ID de site valide, la demande doit provenir du domaine répertorié dans ma base de données associé à cet ID de site.

Voici une option étendue pour apache qui inclut certaines des définitions de police les plus récentes et prévues:

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

Pour faciliter l'accès à plusieurs domaines pour un service ASMX, j'ai créé cette fonction dans le fichier 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();
    }
}

Cela permet OPTIONSégalement la gestion CORS du verbe.

Exemple de code PHP pour faire correspondre les sous-domaines.

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

Pour un copier / coller assez facile pour les applications .NET, j'ai écrit ceci pour activer CORS à partir d'un global.asaxfichier. Ce code suit les conseils donnés dans la réponse actuellement acceptée, reflétant toute origine renvoyée dans la demande dans la réponse. Cela permet effectivement d'atteindre «*» sans l'utiliser.

La raison en est qu'il permet plusieurs autres fonctionnalités CORS , y compris la possibilité d'envoyer un AJAX XMLHttpRequest avec l'attribut 'withCredentials' défini sur '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" , "*");
    }
}

Et une autre réponse dans Django. Pour qu'une vue unique autorise CORS à partir de plusieurs domaines, voici mon 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

Passerelle AWS Lambda / API

Pour plus d'informations sur la configuration de plusieurs origines sur AWS Lambda sans serveur et la passerelle API - bien qu'une solution assez importante pour quelque chose que vous ressentez devrait être assez simple - voir ici:

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

Il n'est actuellement pas possible de configurer plusieurs origines dans API Gateway, voir ici: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), mais la recommandation (dans la réponse ci-dessus) est:

• inspecter l'en-tête Origin envoyé par le navigateur
• vérifier par rapport à une liste blanche des origines
• s'il correspond, renvoyez l'origine entrante comme en-tête Access-Control-Allow-Origin, sinon retournez un espace réservé (origine par défaut).

La solution simple est évidemment d'activer TOUS (*) comme ceci:

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

Mais il pourrait être préférable de le faire du côté de la passerelle API (voir le deuxième lien ci-dessus).

La réponse du support de Google sur la diffusion d'annonces via SSL et la grammaire du RFC lui - même semblent indiquer que vous pouvez délimiter les URL. Je ne sais pas à quel point cela est bien pris en charge dans différents navigateurs.

Si vous essayez autant d'exemples de code comme moi pour le faire fonctionner en utilisant CORS, il convient de mentionner que vous devez d'abord vider votre cache pour essayer s'il fonctionne réellement, semblable à des problèmes comme lorsque de vieilles images sont toujours présentes, même si c'est supprimé sur le serveur (car il est toujours enregistré dans votre cache).

Par exemple CTRL + SHIFT + DELdans Google Chrome pour supprimer votre cache.

Cela m'a aidé à utiliser ce code après avoir essayé de nombreuses .htaccesssolutions pures et cela semblait le seul qui fonctionnait (au moins pour moi):

    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>

Notez également qu'il est largement répandu que de nombreuses solutions disent que vous devez taper, Header set ...mais c'est le cas Header add .... J'espère que cela aide quelqu'un qui a les mêmes problèmes depuis quelques heures comme moi.

La réponse ci-dessous est spécifique à C #, mais le concept devrait être applicable à toutes les différentes plates-formes.

Pour autoriser les demandes d'origine croisée à partir d'une API Web, vous devez autoriser les demandes d'options à votre application et ajouter une annotation ci-dessous au niveau du contrôleur.

[EnableCors (UrlString, Header, Method)] Désormais, les origines ne peuvent être transmises que sous forme de chaîne. SO si vous souhaitez transmettre plusieurs URL dans la demande, transmettez-la en tant que valeur séparée par des virgules.

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

Une seule origine peut être spécifiée pour l'en-tête Access-Control-Allow-Origin. Mais vous pouvez définir l'origine dans votre réponse en fonction de la demande. N'oubliez pas non plus de définir l'en-tête Vary. En PHP, je ferais ce qui suit:

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

Nous pouvons également définir cela dans le fichier Global.asax pour l'application Asp.net.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

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

    }