Acesso-controle-permissão-origem vários domínios de origem?

Existe uma maneira de permitir vários domínios cruzados usando o Access-Control-Allow-Origincabeçalho?

Estou ciente do *, mas é muito aberto. Eu realmente quero permitir apenas alguns domínios.

Como exemplo, algo como isto:

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

Eu tentei o código acima, mas ele não parece funcionar no Firefox.

É possível especificar vários domínios ou estou com apenas um?

Parece que a maneira recomendada de fazer isso é fazer com que o servidor leia o cabeçalho Origin do cliente, compare-o com a lista de domínios que você deseja permitir e, se corresponder, faça eco ao valor do Origincabeçalho de volta ao cliente como o Access-Control-Allow-Origincabeçalho na resposta.

Com .htaccessvocê pode fazer assim:

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

Outra solução que estou usando no 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");
}

Isso funcionou para mim:

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

Quando colocado .htaccess, funcionará com certeza.

Eu tive o mesmo problema com fontes woff, vários subdomínios tinham que ter acesso. Para permitir subdomínios, adicionei algo assim ao meu 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>

Para vários domínios, você pode alterar o regex em SetEnvIf.

A seguir, mostramos como repetir o cabeçalho Origin se ele corresponder ao seu domínio com o Nginx. Isso é útil se você deseja exibir vários subdomínios de fonte:

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

Aqui está o que eu fiz para um aplicativo PHP que está sendo solicitado pelo 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 a origem solicitante for permitida pelo meu servidor, retorne o $http_originvalor como próprio do Access-Control-Allow-Origincabeçalho em vez de retornar um *curinga.

Você deve estar ciente de uma desvantagem: assim que você envia arquivos para uma CDN (ou qualquer outro servidor que não permita scripts) ou se seus arquivos são armazenados em cache em um proxy, alterando a resposta com base em 'Origem' cabeçalho da solicitação não funcionará.

Para vários domínios, em seu .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>

Para usuários do Nginx, permita o CORS para vários domínios. Gosto do exemplo do @ marshall, embora suas respostas correspondam apenas a um domínio. Para corresponder a uma lista de domínio e subdomínio, este regex facilita o trabalho com fontes:

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

Isso fará eco apenas aos cabeçalhos "Controle de acesso-Permitir origem" que correspondam à lista de domínios fornecida.

Para o IIS 7.5+ com o módulo URL Rewrite 2.0 instalado, consulte esta resposta do SO

Aqui está uma solução para o aplicativo da web Java, com base na resposta de yesthatguy.

Estou usando o Jersey REST 1.x

Configure o web.xml para conhecer o Jersey REST e o 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>

Aqui está o código para 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;
}

}

Como mencionado acima, Access-Control-Allow-Origindeve ser único e Varydeve ser definido como Originse você estiver atrás de uma CDN (rede de entrega de conteúdo).

Parte relevante da minha configuração do 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';
}

Talvez eu esteja errado, mas, tanto quanto eu posso ver, Access-Control-Allow-Origintem um "origin-list"parâmetro as.

Por definição, um 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 a partir disso, argumento que diferentes origens são admitidas e devem ser separadas por espaço .

Para aplicativos ExpressJS, você pode usar:

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

Eu lutei para configurá-lo para um domínio executando HTTPS, então imaginei que compartilharia a solução. Eu usei a seguinte diretiva no meu arquivo 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>

Mude example.compara o seu nome de domínio. Adicione isso dentro <VirtualHost x.x.x.x:xx>do seu arquivo httpd.conf . Observe que se o seu VirtualHosttiver um sufixo de porta (por exemplo :80), essa diretiva não se aplicará ao HTTPS, portanto você também precisará acessar / etc / apache2 / sites-available / default-ssl e adicionar a mesma diretiva nesse arquivo, dentro da <VirtualHost _default_:443>seção.

Depois que os arquivos de configuração forem atualizados, você precisará executar os seguintes comandos no terminal:

a2enmod headers
sudo service apache2 reload

Se você estiver tendo problemas com as fontes, use:

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

Uma abordagem mais flexível é usar as expressões do Apache 2.4. Você pode comparar com domínios, caminhos e praticamente todas as outras variáveis ​​de solicitação. Embora a resposta enviada seja sempre *, os únicos solicitantes que a recebem são os que atendem aos requisitos de qualquer maneira. O uso do Origincabeçalho de solicitação (ou qualquer outro) na expressão faz com que o Apache os mescle automaticamente no Varycabeçalho de resposta, para que a resposta não seja reutilizada para uma origem diferente.

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

Código 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ão é usado por todos os navegadores. Quão seguro é HTTP_ORIGIN? Para mim, aparece vazio em FF.
Eu tenho os sites que permitem o acesso ao meu site enviando um ID do site, depois verifico meu banco de dados para o registro com esse ID e obtenho o valor da coluna SITE_URL (www.yoursite.com).

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

Mesmo se você enviar um ID de site válido, a solicitação precisará ser do domínio listado no meu banco de dados associado a esse ID de site.

Aqui está uma opção expandida para o apache que inclui algumas das definições de fonte mais recentes e planejadas:

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

Para facilitar o acesso a vários domínios para um serviço ASMX, criei esta função no arquivo 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();
    }
}

Isso permite o manuseio do OPTIONSverbo CORS também.

Exemplo de código PHP para subdomínios correspondentes.

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

Para uma cópia / colar razoavelmente fácil para aplicativos .NET, escrevi isso para ativar o CORS de dentro de um global.asaxarquivo. Este código segue o conselho dado na resposta atualmente aceita, refletindo a origem na resposta. Isso efetivamente atinge '*' sem usá-lo.

O motivo disso é que ele habilita vários outros recursos do CORS , incluindo a capacidade de enviar um AJAX XMLHttpRequest com o atributo 'withCredentials' definido como '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 mais uma resposta no Django. Para que uma única visualização permita o CORS de vários domínios, eis o meu código:

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

Gateway AWS Lambda / API

Para obter informações sobre como configurar várias origens no AWS Lambda sem servidor e no API Gateway - embora uma solução bastante grande para algo que você ache que deva ser bastante simples - veja aqui:

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

No momento, não é possível configurar várias origens no API Gateway, consulte aqui: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), mas a recomendação (em a resposta acima) é:

• inspecionar o cabeçalho de origem enviado pelo navegador
• compará-lo com uma lista branca de origens
• se corresponder, retorne a Origem de entrada como o cabeçalho Access-Control-Allow-Origin; caso contrário, retorne um espaço reservado (origem padrão).

A solução simples está obviamente habilitando ALL (*) assim:

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

Mas pode ser melhor fazer isso no lado do API Gateway (consulte o segundo link acima).

A resposta de suporte do Google na veiculação de anúncios por SSL e a gramática na própria RFC parece indicar que é possível delimitar espaço os URLs. Não tenho certeza de quão bem isso é suportado em diferentes navegadores.

Se você tentar tantos exemplos de código como eu para fazê-lo funcionar com o CORS, vale a pena mencionar que você deve limpar seu cache primeiro para tentar se ele realmente funciona, semelhante a problemas como quando imagens antigas ainda estão presentes, mesmo que sejam excluído no servidor (porque ainda está salvo no seu cache).

Por exemplo, CTRL + SHIFT + DELno Google Chrome para excluir seu cache.

Isso me ajudou a usar esse código depois de tentar muitas .htaccesssoluções puras e este parecia o único funcionando (pelo menos para mim):

    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>

Observe também que é amplamente difundido que muitas soluções dizem que você precisa digitar, Header set ...mas é Header add .... Espero que isso ajude alguém com os mesmos problemas por algumas horas agora como eu.

A resposta abaixo é específica para C #, mas o conceito deve ser aplicável a todas as plataformas diferentes.

Para permitir solicitações de origem cruzada de uma API da web, é necessário permitir solicitações de opção ao seu aplicativo e adicionar anotação abaixo no nível do controlador.

[EnableCors (UrlString, Header, Method)] Agora, as origens podem ser passadas apenas como string. Portanto, se você deseja passar mais de um URL na solicitação, passe-o como um valor separado por vírgula.

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

Somente uma única origem pode ser especificada para o cabeçalho Access-Control-Allow-Origin. Mas você pode definir a origem da sua resposta de acordo com a solicitação. Também não se esqueça de definir o cabeçalho Vary. No PHP, eu faria o seguinte:

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

Também podemos definir isso no arquivo Global.asax para o aplicativo Asp.net.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

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

    }