Access-control-allow-origin dengan beberapa domain

Di web.config saya, saya ingin menentukan lebih dari satu domain untuk access-control-allow-origindirektif. Saya tidak ingin menggunakan *. Saya sudah mencoba sintaks ini:

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

yang ini

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

yang ini

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

dan yang satu ini

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

tapi tidak ada yang berhasil. Apa sintaks yang benar?

Hanya boleh ada satu Access-Control-Allow-Originheader respons, dan header itu hanya boleh memiliki satu nilai asal. Oleh karena itu, agar ini berfungsi, Anda perlu memiliki beberapa kode yang:

1. Mendapatkan Originheader permintaan.
2. Memeriksa apakah nilai asal adalah salah satu nilai yang masuk daftar putih.
3. Jika valid, setel Access-Control-Allow-Originheader dengan nilai itu.

Saya tidak berpikir ada cara untuk melakukan ini hanya melalui 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");
}

Untuk IIS 7.5+ dan Rewrite 2.0 Anda dapat menggunakan:

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

Menjelaskan bagian variabel server RESPONSE_Access_Control_Allow_Origin:
Dalam Rewrite Anda dapat menggunakan string apa pun setelahnya RESPONSE_dan itu akan membuat Header Respons menggunakan kata lainnya sebagai nama header (dalam hal ini Access-Control-Allow-Origin). Penulisan ulang menggunakan garis bawah "_", bukan tanda hubung "-" (penulisan ulang mengubahnya menjadi tanda hubung)

Menjelaskan variabel server HTTP_ORIGIN:
Demikian pula, di Rewrite Anda dapat mengambil Header Permintaan apa pun yang digunakan HTTP_sebagai awalan. Aturan yang sama dengan tanda hubung (gunakan garis bawah "_", bukan tanda hubung "-").

Di Web.API , atribut ini dapat ditambahkan menggunakan Microsoft.AspNet.WebApi.Corsseperti yang dijelaskan di http://www.asp.net/web-api/overview/security/enabling-cross-origin-requests-in-web-api

Di MVC Anda dapat membuat atribut filter untuk melakukan pekerjaan ini untuk Anda:

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

Kemudian aktifkan untuk tindakan / pengontrol tertentu:

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

Atau tambahkan untuk semua pengontrol di 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
}

Setelah membaca setiap jawaban dan mencobanya, tidak ada yang membantu saya. Apa yang saya temukan saat mencari di tempat lain adalah Anda dapat membuat atribut khusus yang kemudian dapat Anda tambahkan ke pengontrol. Ini menimpa yang EnableCors dan menambahkan domain yang masuk daftar putih di dalamnya.

Solusi ini berfungsi dengan baik karena memungkinkan Anda memiliki domain yang masuk daftar putih di webconfig (setelan aplikasi) alih-alih melakukan harcoding di atribut EnableCors pada pengontrol Anda.

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

Saya menemukan panduan ini secara online dan bekerja dengan sangat baik:

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

Saya pikir saya akan menjatuhkannya di sini untuk siapa pun yang membutuhkan.

Saya berhasil menyelesaikan ini dalam kode penanganan Permintaan mengikuti saran dari 'monsur'.

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

WebOperationContext.Current.OutgoingResponse.Headers.Add("Access-Control-Allow-Origin", origin);

Untuk IIS 7.5+ Anda dapat menggunakan IIS CORS Module: https://www.iis.net/downloads/microsoft/iis-cors-module

Web.config Anda harus seperti ini:

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

Anda dapat menemukan referensi konfigurasi di sini: https://docs.microsoft.com/en-us/iis/extensions/cors-module/cors-module-configuration-reference

Lihat ke dalam pustaka Thinktecture IdentityModel - ini memiliki dukungan CORS penuh:

http://brockallen.com/2012/06/28/cors-support-in-webapi-mvc-and-iis-with-thinktecture-identitymodel/

Dan secara dinamis dapat memancarkan ACA-Origin yang Anda inginkan.

Anda dapat menambahkan kode ini ke proyek webapi asp.net Anda

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

Anda dapat menggunakan middleware owin untuk menentukan kebijakan cors di mana Anda dapat menentukan beberapa asal 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);
                }
            }
        };

Anda hanya membutuhkan:

• tambahkan Global.asax ke proyek Anda,
• hapus <add name="Access-Control-Allow-Origin" value="*" />dari web.config Anda.

• setelah itu, tambahkan ini ke Application_BeginRequestmetode 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();
  }

Saya berharap bantuan ini. itu berhasil untuk saya.