Access-control-allow-origin z wieloma domenami

99

W moim web.config chciałbym określić więcej niż jedną domenę dla access-control-allow-origindyrektywy. Nie chcę używać *. Wypróbowałem tę składnię:

<add name="Access-Control-Allow-Origin" value="http://localhost:1506, http://localhost:1502" />

ten

<add name="Access-Control-Allow-Origin" value="http://localhost:1506 http://localhost:1502" />

ten

<add name="Access-Control-Allow-Origin" value="http://localhost:1506; http://localhost:1502" />

i ten

<add name="Access-Control-Allow-Origin" value="http://localhost:1506" />
<add name="Access-Control-Allow-Origin" value="http://localhost:1502" />

ale żaden z nich nie działa. Jaka jest prawidłowa składnia?

Sam
źródło

Odpowiedzi:

79

Może istnieć tylko jeden Access-Control-Allow-Originnagłówek odpowiedzi, a ten nagłówek może mieć tylko jedną wartość pochodzenia. Dlatego, aby to zadziałało, musisz mieć kod, który:

  1. Przechwytuje Originnagłówek żądania.
  2. Sprawdza, czy wartość pochodzenia jest jedną z wartości na białej liście.
  3. Jeśli jest prawidłowy, ustawia Access-Control-Allow-Originnagłówek z tą wartością.

Nie sądzę, aby można było to zrobić wyłącznie przez plik web.config.

if (ValidateRequest()) {
    Response.Headers.Remove("Access-Control-Allow-Origin");
    Response.AddHeader("Access-Control-Allow-Origin", Request.UrlReferrer.GetLeftPart(UriPartial.Authority));

    Response.Headers.Remove("Access-Control-Allow-Credentials");
    Response.AddHeader("Access-Control-Allow-Credentials", "true");

    Response.Headers.Remove("Access-Control-Allow-Methods");
    Response.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
}
monsur
źródło
2
To odpowiada na moje pytanie. Nie jestem pewien, dlaczego Microsoft nie zezwala na określanie wielu źródeł w pliku web.config ...
Sam
17
Gdzie mogę dodać ten kod? Mam zwykłe pliki tekstowe generowane przez serwer i czytane przez AJAX, w ogóle nie ma kodu. Gdzie mogę umieścić kod ograniczający dostęp do plików tekstowych w moim katalogu?
Harry,
3
@Simon_Weaver istnieje *wartość, która umożliwia dowolnemu źródłu dostęp do zasobu. Jednak pierwotne pytanie dotyczyło umieszczenia zestawu domen na białej liście.
monsur
2
ponieważ jestem nowy w asp .net, czy mogę zapytać, gdzie mogę umieścić ten kod w moim projekcie web api asp .net?
Amrit
93

W przypadku usług IIS 7.5+ i Rewrite 2.0 można użyć:

<system.webServer>
   <httpProtocol>
     <customHeaders>
         <add name="Access-Control-Allow-Headers" value="Origin, X-Requested-With, Content-Type, Accept" />
         <add name="Access-Control-Allow-Methods" value="POST,GET,OPTIONS,PUT,DELETE" />
     </customHeaders>
   </httpProtocol>
        <rewrite>            
            <outboundRules>
                <clear />                
                <rule name="AddCrossDomainHeader">
                    <match serverVariable="RESPONSE_Access_Control_Allow_Origin" pattern=".*" />
                    <conditions logicalGrouping="MatchAll" trackAllCaptures="true">
                        <add input="{HTTP_ORIGIN}" pattern="(http(s)?://((.+\.)?domain1\.com|(.+\.)?domain2\.com|(.+\.)?domain3\.com))" />
                    </conditions>
                    <action type="Rewrite" value="{C:0}" />
                </rule>           
            </outboundRules>
        </rewrite>
 </system.webServer>

Wyjaśnienie RESPONSE_Access_Control_Allow_Originczęści zmiennej serwera :
W Rewrite możesz użyć dowolnego ciągu po RESPONSE_i utworzy on nagłówek odpowiedzi, używając reszty słowa jako nazwy nagłówka (w tym przypadku Access-Control-Allow-Origin). Rewrite używa podkreślenia „_” zamiast myślników „-” (rewrite konwertuje je na myślniki)

Wyjaśnienie zmiennej serwera HTTP_ORIGIN:
Podobnie, w Rewrite możesz pobrać dowolny nagłówek żądania, używając HTTP_jako prefiksu. Te same zasady z myślnikami (użyj podkreślenia „_” zamiast myślników „-”).

Paco Zarate
źródło
Czy potrafisz wymyślić jakieś powody, dla których nie działałoby to z usługami IIS 7.5?
Phil Ricketts
Myślę, że to powinno działać. Określiłem wersję IIS 8.5, ponieważ tam ją przetestowałem.
Paco Zarate
4
@PacoZarate Niezła, świetna wskazówka. Aby uprościć wyrażenie regularne i uczynić je bardziej ogólnym, możesz użyć - (http(s)?:\/\/((.+\.)?(domain1|domain2)\.(com|org|net))). W ten sposób możesz dość łatwo dodawać inne domeny i obsługiwać wiele domen najwyższego poziomu (np. Com, org, net itp.).
Merlin
4
Właśnie wypróbowałem to w usługach IIS 7.5. Wydaje się, że działa dobrze.
Przewidziano
2
Masz problem z buforowaniem? Po poprawieniu pliku web.config pierwsza witryna, do której przechodzę, pasuje dobrze, ale druga zwraca ten sam nagłówek, co pierwsza. W ten sposób domeny nie są zbyt dopasowane.
Airn5475
20

W interfejsie Web.API ten atrybut można dodać Microsoft.AspNet.WebApi.Corszgodnie z opisem podanym na stronie http://www.asp.net/web-api/overview/security/eniring-cross-origin-requests-in-web-api

W MVC możesz utworzyć atrybut filtru, aby wykonać tę pracę za Ciebie:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method,
                AllowMultiple = true, Inherited = true)]
public class EnableCorsAttribute : FilterAttribute, IActionFilter {
    private const string IncomingOriginHeader = "Origin";
    private const string OutgoingOriginHeader = "Access-Control-Allow-Origin";
    private const string OutgoingMethodsHeader = "Access-Control-Allow-Methods";
    private const string OutgoingAgeHeader = "Access-Control-Max-Age";

    public void OnActionExecuted(ActionExecutedContext filterContext) {
        // Do nothing
    }

    public void OnActionExecuting(ActionExecutingContext filterContext)
    {
        var isLocal = filterContext.HttpContext.Request.IsLocal;
        var originHeader = 
             filterContext.HttpContext.Request.Headers.Get(IncomingOriginHeader);
        var response = filterContext.HttpContext.Response;

        if (!String.IsNullOrWhiteSpace(originHeader) &&
            (isLocal || IsAllowedOrigin(originHeader))) {
            response.AddHeader(OutgoingOriginHeader, originHeader);
            response.AddHeader(OutgoingMethodsHeader, "GET,POST,OPTIONS");
            response.AddHeader(OutgoingAgeHeader, "3600");
        }
    }

    protected bool IsAllowedOrigin(string origin) {
        // ** replace with your own logic to check the origin header
        return true;
    }
}

Następnie włącz go dla określonych akcji / kontrolerów:

[EnableCors]
public class SecurityController : Controller {
    // *snip*
    [EnableCors]
    public ActionResult SignIn(Guid key, string email, string password) {

Lub dodaj go dla wszystkich kontrolerów w Global.asax.cs

protected void Application_Start() {
    // *Snip* any existing code

    // Register global filter
    GlobalFilters.Filters.Add(new EnableCorsAttribute());
    RegisterGlobalFilters(GlobalFilters.Filters);

    // *snip* existing code
}
Rob Church
źródło
Czy wiesz, w jakich wersjach .Net / MVC to działa?
Keab42
Z powodzeniem używam tego w .net 4 / MVC 3 - o ile wiem, powinno działać w wyższych wersjach, ale może istnieć preferowany sposób rejestracji globalnego filtra w późniejszych wersjach MVC.
Rob Church
proszę tylko zwrócić uwagę na jego rozwiązanie WEB API 2. nie dla WEB API 1.
Samih A
5

Po przeczytaniu wszystkich odpowiedzi i wypróbowaniu ich, żadna z nich mi nie pomogła. Podczas wyszukiwania w innym miejscu odkryłem, że możesz utworzyć atrybut niestandardowy, który możesz następnie dodać do kontrolera. Zastępuje EnableCors i dodaje do niego domeny z białej listy.

To rozwiązanie działa dobrze, ponieważ umożliwia umieszczenie domen z białej listy w webconfig (appsettings) zamiast kodowania ich w atrybucie EnableCors na kontrolerze.

 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
public class EnableCorsByAppSettingAttribute : Attribute, ICorsPolicyProvider
{
    const string defaultKey = "whiteListDomainCors";
    private readonly string rawOrigins;
    private CorsPolicy corsPolicy;

    /// <summary>
    /// By default uses "cors:AllowedOrigins" AppSetting key
    /// </summary>
    public EnableCorsByAppSettingAttribute()
        : this(defaultKey) // Use default AppSetting key
    {
    }

    /// <summary>
    /// Enables Cross Origin
    /// </summary>
    /// <param name="appSettingKey">AppSetting key that defines valid origins</param>
    public EnableCorsByAppSettingAttribute(string appSettingKey)
    {
        // Collect comma separated origins
        this.rawOrigins = AppSettings.whiteListDomainCors;
        this.BuildCorsPolicy();
    }

    /// <summary>
    /// Build Cors policy
    /// </summary>
    private void BuildCorsPolicy()
    {
        bool allowAnyHeader = String.IsNullOrEmpty(this.Headers) || this.Headers == "*";
        bool allowAnyMethod = String.IsNullOrEmpty(this.Methods) || this.Methods == "*";

        this.corsPolicy = new CorsPolicy
        {
            AllowAnyHeader = allowAnyHeader,
            AllowAnyMethod = allowAnyMethod,
        };

        // Add origins from app setting value
        this.corsPolicy.Origins.AddCommaSeperatedValues(this.rawOrigins);
        this.corsPolicy.Headers.AddCommaSeperatedValues(this.Headers);
        this.corsPolicy.Methods.AddCommaSeperatedValues(this.Methods);
    }

    public string Headers { get; set; }
    public string Methods { get; set; }

    public Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request,
                                               CancellationToken cancellationToken)
    {
        return Task.FromResult(this.corsPolicy);
    }
}

    internal static class CollectionExtensions
{
    public static void AddCommaSeperatedValues(this ICollection<string> current, string raw)
    {
        if (current == null)
        {
            return;
        }

        var paths = new List<string>(AppSettings.whiteListDomainCors.Split(new char[] { ',' }));
        foreach (var value in paths)
        {
            current.Add(value);
        }
    }
}

Znalazłem ten przewodnik online i działał jak marzenie:

http://jnye.co/Posts/2032/dynamic-cors-origins-from-appsettings-using-web-api-2-2-cross-origin-support

Pomyślałem, że zostawię to tutaj dla każdego w potrzebie.

Helpha
źródło
To jest odpowiedź zawierająca tylko łącze. Zamiast tego odpowiedz sobie samodzielnie.
Unslander Monica
1
Ok, jestem tutaj nowy, czy to bardziej przypomina to, co powinno być?
Helpha
3

Udało mi się rozwiązać ten problem w kodzie obsługi wniosków zgodnie z radą „monsur”.

string origin = WebOperationContext.Current.IncomingRequest.Headers.Get("Origin");

WebOperationContext.Current.OutgoingResponse.Headers.Add("Access-Control-Allow-Origin", origin);
bsandhu
źródło
Tak jest na przykład w formularzu internetowym. Po prostu użyj Request.Headers, jeśli są dostępne. W razie potrzeby użyj białej listy, aby odfiltrować tylko dozwolone domeny.
AFract
3
To jest tak dobre, jak dodanie <add name = "Access-Control-Allow-Origin" value = "*" /> w pliku web.config
Isaiah4110,
3

W przypadku usług IIS 7.5+ można użyć modułu IIS CORS: https://www.iis.net/downloads/microsoft/iis-cors-module

Twój plik web.config powinien wyglądać mniej więcej tak:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <system.webServer>
        <cors enabled="true" failUnlistedOrigins="true">
            <add origin="http://localhost:1506">
                <allowMethods>                    
                    <add method="GET" />
                    <add method="HEAD" />
                    <add method="POST" />
                    <add method="PUT" /> 
                    <add method="DELETE" /> 
                </allowMethods>
            </add>
            <add origin="http://localhost:1502">
                <allowMethods>
                    <add method="GET" />
                    <add method="HEAD" />
                    <add method="POST" />
                    <add method="PUT" /> 
                    <add method="DELETE" /> 
                </allowMethods>
            </add>
        </cors>
    </system.webServer>
</configuration>

Informacje o konfiguracji można znaleźć tutaj: https://docs.microsoft.com/en-us/iis/extensions/cors-module/cors-module-configuration-reference

Mario Arturo
źródło
Jeśli to działa tak, jak mówi, chciałbym, żebyś opublikował to 3 lata temu! Whoa!
Michael
1

Możesz dodać ten kod do projektu webapi asp.net

w pliku Global.asax

    protected void Application_BeginRequest()
{
    string origin = Request.Headers.Get("Origin");
    if (Request.HttpMethod == "OPTIONS")
    {
        Response.AddHeader("Access-Control-Allow-Origin", origin);
        Response.AddHeader("Access-Control-Allow-Headers", "*");
        Response.AddHeader("Access-Control-Allow-Methods", "GET,POST,PUT,OPTIONS,DELETE");
        Response.StatusCode = 200;
        Response.End();
    }
    else
    {
        Response.AddHeader("Access-Control-Allow-Origin", origin);
        Response.AddHeader("Access-Control-Allow-Headers", "*");
        Response.AddHeader("Access-Control-Allow-Methods", "GET,POST,PUT,OPTIONS,DELETE");
    }
}
Jackdon Wang
źródło
0

Możesz użyć własnego oprogramowania pośredniczącego, aby zdefiniować zasady cors, w których można zdefiniować wiele źródeł cors

return new CorsOptions
        {
            PolicyProvider = new CorsPolicyProvider
            {
                PolicyResolver = context =>
                {
                    var policy = new CorsPolicy()
                    {
                        AllowAnyOrigin = false,
                        AllowAnyMethod = true,
                        AllowAnyHeader = true,
                        SupportsCredentials = true
                    };
                    policy.Origins.Add("http://foo.com");
                    policy.Origins.Add("http://bar.com");
                    return Task.FromResult(policy);
                }
            }
        };
chayan banerjee
źródło
-3

Potrzebujesz tylko:

  • dodaj Global.asax do swojego projektu,
  • usuń <add name="Access-Control-Allow-Origin" value="*" />z pliku web.config.
  • potem dodaj to w Application_BeginRequestmetodzie Global.asax:

    HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin","*");
    
    if (HttpContext.Current.Request.HttpMethod == "OPTIONS")
    {
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Methods", "POST,GET,OPTIONS,PUT,DELETE");
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept");
        HttpContext.Current.Response.End();
    }

Mam nadzieję, że to pomoże. to działa dla mnie.

joanrm20
źródło
Dodanie „...- Origin: *” działa z wyjątkiem sytuacji, gdy zezwalasz na poświadczenia. Jeśli masz zezwolenie na uwierzytelnianie ustawione na true, musisz określić domenę (nie tylko *). Na tym polega sedno tego problemu. W przeciwnym razie możesz po prostu określić „... allow-credentials: false” i skończyć z tym.
Richard,