Aktivera CORS (Cross-Origin Requests) i ASP.NET Core

Av Rick Anderson och Kirk Larkin

Den här artikeln visar hur Cross-Origin Resource Sharing (CORS) aktiveras i en ASP.NET Core-app.

Webbläsarsäkerhet hindrar en webbsida från att göra begäranden till en annan domän än den som hanterade webbsidan. Den här begränsningen kallas principen för samma ursprung. Principen för samma ursprung förhindrar att en skadlig webbplats läser känsliga data från en annan webbplats. Ibland kanske du vill tillåta att andra webbplatser gör cross-origin-förfrågningar till din app. Mer information finns i artikeln Mozilla CORS.

Resursdelning mellan ursprung (CORS):

• Är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
• Är inte en säkerhetsfunktion, CORS slappnar av säkerheten. Ett API är inte säkrare genom att tillåta CORS. Mer information finns i Så här fungerar CORS.
• Tillåter att en server uttryckligen tillåter vissa begäranden mellan ursprung samtidigt som andra avvisas.
• Är säkrare och mer flexibelt än tidigare tekniker, till exempel JSONP.

Visa eller ladda ned exempelkod (hur du laddar ned)

Samma ursprung

Två URL:er har samma ursprung om de har identiska scheman, värdar och portar (RFC 6454).

Dessa två URL:er har samma ursprung:

• https://example.com/foo.html
• https://example.com/bar.html

Dessa URL:er har olika ursprung än de föregående två URL:erna:

• https://example.net: Olika domän
• https://contoso.example.com/foo.html: Olika underdomäner
• http://example.com/foo.html: Olika schema
• https://example.com:9000/foo.html: Annorlunda port

Aktivera CORS

Det finns tre sätt att aktivera CORS:

• I mellanprogram med hjälp av en namngiven princip eller standardprincip.
• Använda slutpunktsroutning.
• Med attributet [EnableCors] .

Med attributet [EnableCors] med en namngiven princip får du den bästa kontrollen när det gäller att begränsa slutpunkter som stöder CORS.

Varje metod beskrivs i följande avsnitt.

CORS med namngiven princip och mellanprogram

CORS Middleware hanterar ursprungsöverskridande begäranden. Följande kod tillämpar en CORS-princip på alla appens slutpunkter med angivet ursprung:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod:

• Anger principnamnet till _myAllowSpecificOrigins. Principnamnet är godtyckligt.
• UseCors Anropar tilläggsmetoden och anger _myAllowSpecificOrigins CORS-principen. UseCors lägger till CORS-mellanprogrammet. Anropet till UseCors måste placeras efter UseRouting, men före UseAuthorization. Mer information finns i Mellanprogramvaruordning.
• Anropar AddCors med ett lambda-uttryck. Lambda tar ett CorsPolicyBuilder objekt. Konfigurationsalternativ, till exempel WithOrigins, beskrivs senare i den här artikeln.
• _myAllowSpecificOrigins Aktiverar CORS-principen för alla kontrollantslutpunkter. Se Slutpunktsroutning för att tillämpa en CORS-princip på specifika slutpunkter.
• När du använder Mellanprogramvara för svarscachelagring anropar du UseCors före UseResponseCaching.

Med slutpunktsroutning måste CORS-mellanprogrammet konfigureras för att köras mellan anropen till UseRouting och UseEndpoints.

Metodanropet AddCors lägger till CORS-tjänster i appens tjänstcontainer:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Mer information finns i CORS-principalternativ i det här dokumentet.

Metoderna CorsPolicyBuilder kan länkas, enligt följande kod:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(MyAllowSpecificOrigins,
                          policy =>
                          {
                              policy.WithOrigins("http://example.com",
                                                  "http://www.contoso.com")
                                                  .AllowAnyHeader()
                                                  .AllowAnyMethod();
                          });
});

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Obs! Den angivna URL:en får inte innehålla ett avslutande snedstreck (/). Om URL:en avslutas med /, returneras false och ingen header returneras.

Ordning för UseCors och UseStaticFiles

UseStaticFiles Anropas vanligtvis före UseCors. Appar som använder JavaScript för att hämta statiska filer mellan webbplatser måste anropas UseCors före UseStaticFiles.

CORS med standardprincip och mellanprogram

Följande markerade kod aktiverar standardprincipen för CORS:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod tillämpar cors-standardprincipen på alla kontrollantslutpunkter.

Aktivera Cors med slutpunktsroutning

Med slutpunktsroutning kan CORS aktiveras per slutpunkt med hjälp RequireCors av uppsättningen med tilläggsmetoder:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/echo",
        context => context.Response.WriteAsync("echo"))
        .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapControllers()
             .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapGet("/echo2",
        context => context.Response.WriteAsync("echo2"));

    endpoints.MapRazorPages();
});

app.Run();

I koden ovan:

• app.UseCors aktiverar CORS-mellanprogrammet. Eftersom en standardprincip inte har konfigurerats, aktiverar inte app.UseCors() ensam CORS.
• /echo och kontrollerändpunkterna tillåter begäranden över ursprungsgränser enligt den angivna policyn.
• Slutpunkterna /echo2 och Razor Pages tillåter inte begäranden mellan ursprung eftersom ingen standardprincip har angetts.

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning med RequireCors.

Se Testa CORS med attributet [EnableCors] och RequireCors-metoden för instruktioner om att testa kod som liknar föregående.

Aktivera CORS med attribut

Att aktivera CORS med attributet [EnableCors] och tillämpa en namngiven princip på endast de slutpunkter som kräver CORS ger den bästa kontrollen.

Attributet [EnableCors] är ett alternativ till att tillämpa CORS globalt. Attributet [EnableCors] aktiverar CORS för valda slutpunkter i stället för alla slutpunkter:

• [EnableCors] anger standardprincipen.
• [EnableCors("{Policy String}")] anger en namngiven princip.

Attributet [EnableCors] kan tillämpas på:

• Razor Sida PageModel
• Controller
• Kontrollantåtgärdsmetod

Olika principer kan tillämpas på kontrollanter, sidmodeller eller åtgärdsmetoder med attributet [EnableCors] . [EnableCors] När attributet tillämpas på en kontrollant, sidmodell eller åtgärdsmetod, och CORS är aktiverat i mellanprogram, tillämpas båda principerna. Vi rekommenderar att du inte kombinerar principer. Använd [EnableCors] attribut eller mellanprogram, inte båda i samma app.

Följande kod tillämpar en annan princip på varje metod:

[Route("api/[controller]")]
[ApiController]
public class WidgetController : ControllerBase
{
    // GET api/values
    [EnableCors("AnotherPolicy")]
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "green widget", "red widget" };
    }

    // GET api/values/5
    [EnableCors("Policy1")]
    [HttpGet("{id}")]
    public ActionResult<string> Get(int id)
    {
        return id switch
        {
            1 => "green widget",
            2 => "red widget",
            _ => NotFound(),
        };
    }
}

Följande kod skapar två CORS-principer:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("Policy1",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });

    options.AddPolicy("AnotherPolicy",
        policy =>
        {
            policy.WithOrigins("http://www.contoso.com")
                                .AllowAnyHeader()
                                .AllowAnyMethod();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

För den bästa kontrollen av att begränsa CORS-begäranden:

• Använd [EnableCors("MyPolicy")] med en namngiven princip.
• Definiera inte en standardprincip.
• Använd inte slutpunktsroutning.

Koden i nästa avsnitt uppfyller föregående lista.

Inaktivera CORS

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning.

Följande kod definierar CORS-principen "MyPolicy":

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com")
                    .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints => {
    endpoints.MapControllers();
    endpoints.MapRazorPages();
});

app.Run();

Följande kod inaktiverar CORS för åtgärden GetValues2 :

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

Föregående kod:

• Aktiverar inte CORS med slutpunktsroutning.
• Definierar inte någon CORS-standardprincip.
• Använder [EnableCors("MyPolicy")] för att aktivera "MyPolicy" CORS-principen för kontrollanten.
• Inaktiverar CORS för GetValues2 metoden.

Mer information om hur du testar koden ovan finns i Testa CORS .

Alternativ för CORS-policy

I det här avsnittet beskrivs de olika alternativ som kan anges i en CORS-princip:

• Ange de tillåtna ursprungen
• Ange tillåtna HTTP-metoder
• Ange de tillåtna begäranderubrikerna
• Ange de synliga svarshuvudena
• Autentiseringsuppgifter i begäranden mellan ursprung
• Ange förtidsförfallotiden

AddPolicy anropas i Program.cs. För vissa alternativ kan det vara bra att läsa avsnittet Hur CORS fungerar först.

Ange de tillåtna ursprungen

AllowAnyOrigin: Tillåter CORS-begäranden från alla ursprung med valfritt schema (http eller https). AllowAnyOrigin är osäker eftersom vilken som helst webbplats kan göra korsursprungsbegäranden till appen.

AllowAnyOrigin påverkar preflightbegäranden och Access-Control-Allow-Origin huvud. Mer information finns i avsnittet Preflight-begäranden .

SetIsOriginAllowedToAllowWildcardSubdomains: Anger IsOriginAllowed att principens egenskap ska vara en funktion som tillåter att ursprung matchar en konfigurerad jokerteckendomän när du utvärderar om ursprunget tillåts.

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://example.com")
                .SetIsOriginAllowedToAllowWildcardSubdomains();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

I föregående kod anropas SetIsOriginAllowedToAllowWildcardSubdomains med basursprung "https://example.com". Den här konfigurationen tillåter CORS-begäranden från alla underdomäner i example.com, till exempel https://subdomain.example.com eller https://api.example.com. Jokerteckenmatchningen hanteras av metoden, så ursprunget ska anges utan * jokertecknet.

Ange tillåtna HTTP-metoder

AllowAnyMethod:

• Tillåter alla HTTP-metoder:
• Påverkar preflight-begäranden och Access-Control-Allow-Methods headern. Mer information finns i avsnittet Preflight-begäranden .

Ange de tillåtna begäranderubrikerna

Om du vill tillåta att specifika rubriker skickas i en CORS-begäran, kallad förfrågningsrubriker, anropar du WithHeaders och anger de tillåtna rubrikerna:

using Microsoft.Net.Http.Headers;

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
       policy =>
       {
           policy.WithOrigins("http://example.com")
                  .WithHeaders(HeaderNames.ContentType, "x-custom-header");
       });
});

builder.Services.AddControllers();

var app = builder.Build();

Om du vill tillåta alla författarförfrågningsrubriker anropar du AllowAnyHeader:

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

AllowAnyHeader påverkar preflight-begäranden och 'Access-Control-Request-Headers'-headern. Mer information finns i avsnittet Preflight-begäranden .

En matchning av CORS Middleware-policy mot specifika rubriker som specificeras av WithHeaders är endast möjlig när rubrikerna som skickas i Access-Control-Request-Headers exakt matchar de rubriker som anges i WithHeaders.

Anta till exempel att en app har konfigurerats på följande sätt:

app.UseCors(policy => policy.WithHeaders(HeaderNames.CacheControl));

CORS Middleware nekar en förhandsbegäran med följande begärandehuvud eftersom Content-Language (HeaderNames.ContentLanguage) inte visas i WithHeaders:

Access-Control-Request-Headers: Cache-Control, Content-Language

Appen returnerar ett 200 OK-svar men skickar inte CORS-huvudena tillbaka. Därför försöker inte webbläsaren skicka begäran om korsande ursprung.

Ange de synliga svarshuvudena

Som standardinställning exponerar inte webbläsaren alla svarshuvuden till appen. Mer information finns i Resursdelning mellan ursprung i W3C (terminologi): Enkelt svarshuvud.

Svarshuvudena som är tillgängliga som standard är:

• Cache-Control
• Content-Language
• Content-Type
• Expires
• Last-Modified
• Pragma

CORS-specifikationen kallar dessa rubriker enkla svarsrubriker. Om du vill göra andra rubriker tillgängliga för appen anropar du WithExposedHeaders:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyExposeResponseHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .WithExposedHeaders("x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Autentiseringsuppgifter i begäranden mellan ursprung

Autentiseringsuppgifter kräver särskild hantering i en CORS-begäran. Som standard skickar webbläsaren inte autentiseringsuppgifter med en begäran om korsande ursprung. Autentiseringsuppgifterna omfattar cookies och HTTP-autentiseringsscheman. Om du vill skicka autentiseringsuppgifter med en begäran om korsande ursprung måste klienten ange XMLHttpRequest.withCredentials till true.

Använder XMLHttpRequest direkt:

var xhr = new XMLHttpRequest();
xhr.open('get', 'https://www.example.com/api/test');
xhr.withCredentials = true;

Använda jQuery:

$.ajax({
  type: 'get',
  url: 'https://www.example.com/api/test',
  xhrFields: {
    withCredentials: true
  }
});

Använda Fetch API:

fetch('https://www.example.com/api/test', {
    credentials: 'include'
});

Servern måste tillåta autentiseringsuppgifterna. Om du vill tillåta autentiseringsuppgifter mellan ursprung anropar du AllowCredentials:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyMyAllowCredentialsPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .AllowCredentials();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

HTTP-svaret innehåller en Access-Control-Allow-Credentials rubrik som talar om för webbläsaren att servern tillåter autentiseringsuppgifter för en begäran om korsande ursprung.

Om webbläsaren skickar autentiseringsuppgifter men svaret inte innehåller ett giltigt Access-Control-Allow-Credentials huvud exponerar inte webbläsaren svaret för appen och begäran om korsande ursprung misslyckas.

Att tillåta autentiseringsuppgifter mellan ursprung är en säkerhetsrisk. En webbplats på en annan domän kan skicka en inloggad användares autentiseringsuppgifter till appen för användarens räkning utan användarens vetskap.

CORS-specifikationen anger också att att ställa in ursprung till "*" (alla ursprung) är ogiltig om Access-Control-Allow-Credentials headern finns.

Preflight-begäranden

För vissa CORS-begäranden skickar webbläsaren ytterligare en OPTIONS-begäran innan den faktiska begäran görs. Den här begäran kallas för en preflight-begäran. Webbläsaren kan hoppa över preflight-begäran om alla följande villkor är uppfyllda:

• Begärandemetoden är GET, HEAD eller POST.
• Appen anger inte andra begärandehuvuden än Accept, Accept-Language, Content-Language, Content-Typeeller Last-Event-ID.
• Rubriken Content-Type , om den anges, har något av följande värden:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Regeln för begärandehuvuden som angetts för klientbegäran gäller för rubriker som appen anger genom att anropa setRequestHeaderXMLHttpRequest objektet. CORS-specifikationen kallar dessa rubriker förfrågningsrubriker från författare. Regeln gäller inte för rubriker som webbläsaren kan ange, till exempel User-Agent, Hosteller Content-Length.

Följande är ett exempelsvar som liknar preflight-begäran från knappen [Put test] i avsnittet Test CORS i det här dokumentet.

General:
Request URL: https://cors3.azurewebsites.net/api/values/5
Request Method: OPTIONS
Status Code: 204 No Content

Response Headers:
Access-Control-Allow-Methods: PUT,DELETE,GET
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f8...8;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Vary: Origin

Request Headers:
Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Method: PUT
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

Preflight-begäran använder metoden HTTP OPTIONS . Den kan innehålla följande rubriker:

• Access-Control-Request-Method: DEN HTTP-metod som ska användas för den faktiska begäran.
• Access-Control-Request-Headers: En lista över begärandehuvuden som appen anger för den faktiska begäran. Som tidigare nämnts innehåller detta inte rubriker som webbläsaren anger, till exempel User-Agent.

Om preflight-begäran nekas returnerar appen ett 200 OK svar men anger inte CORS-huvudena. Därför försöker inte webbläsaren skicka begäran om korsande ursprung. Ett exempel på en nekad preflight-begäran finns i avsnittet Testa CORS i det här dokumentet.

Med hjälp av F12-verktygen visar konsolappen ett fel som liknar något av följande, beroende på webbläsaren:

• Firefox: Begäran om korsande ursprung blockerad: Samma ursprungsprincip tillåter inte läsning av fjärrresursen på https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5. (Orsak: CORS-begäran lyckades inte). Lära sig mer
• Chromium-baserad: Åtkomst till fetch vid 'https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Svaret på förhandsbegäran passerar inte åtkomstkontrollen: Inget "Access-Control-Allow-Origin"-huvud finns på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

Om du vill tillåta specifika rubriker anropar du WithHeaders:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowHeadersPolicy",
        policy =>
        {
        policy.WithOrigins("http://example.com")
                   .WithHeaders(HeaderNames.ContentType, "x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Om du vill tillåta alla författarförfrågningsrubriker anropar du AllowAnyHeader:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowAllHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Webbläsare är inte konsekventa i hur de anger Access-Control-Request-Headers. Om något av följande:

• Rubriker är inställda på något annat än "*"
• AllowAnyHeader heter: Inkludera minst Accept, Content-Typeoch Origin, plus alla anpassade rubriker som du vill stödja.

Automatisk kod för förhandsbegäran

När CORS-principen antingen tillämpas:

• Globalt genom att anropa app.UseCors i Program.cs.
• Använda attributet [EnableCors] .

ASP.NET Core svarar på preflight OPTIONS-begäran.

Avsnittet Test CORS i det här dokumentet visar det här beteendet.

[HttpOptions]-attribut för preflight-begäranden

När CORS är aktiverat med rätt princip svarar ASP.NET Core vanligtvis på CORS-förhandsbegäranden automatiskt.

Följande kod använder attributet [HttpOptions] för att skapa slutpunkter för OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

Mer information om hur du testar koden ovan finns i Testa CORS med attributet [EnableCors] och RequireCors-metoden .

Ange förtidsförfallotiden

Rubriken Access-Control-Max-Age anger hur länge svaret på preflight-begäran kan cachelagras. Om du vill ange den här rubriken anropar du SetPreflightMaxAge:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MySetPreflightExpirationPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .SetPreflightMaxAge(TimeSpan.FromSeconds(2520));
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Aktivera CORS på en slutpunkt

Så här fungerar CORS

I det här avsnittet beskrivs vad som händer i en CORS-begäran på HTTP-meddelandenas nivå.

• CORS är inte en säkerhetsfunktion. CORS är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
  • En illasinnad aktör kan till exempel använda XSS (Cross-Site Scripting) mot din webbplats och köra en begäran mellan platser till deras CORS-aktiverade webbplats för att stjäla information.
• Ett API är inte säkrare genom att tillåta CORS.
  • Det är upp till klienten (webbläsaren) att framtvinga CORS. Servern kör begäran och returnerar svaret. Det är klienten som returnerar ett fel och blockerar svaret. Något av följande verktyg visar till exempel serversvaret:
    • Fiddler
    • .NET HttpClient
    • En webbläsare genom att ange URL:en i adressfältet.
• Det är ett sätt för en server att tillåta webbläsare att köra en XHR - eller Fetch API-begäran mellan ursprung som annars skulle vara förbjuden.
  • Webbläsare utan CORS kan inte göra begäranden mellan ursprung. Före CORS användes JSONP för att kringgå denna begränsning. JSONP använder inte XHR, den använder taggen <script> för att ta emot svaret. Skript tillåts att laddas från olika ursprung.

CORS-specifikationen introducerade flera nya HTTP-huvuden som möjliggör begäranden mellan ursprung. Om en webbläsare stöder CORS anger den dessa huvuden automatiskt för begäranden mellan olika ursprung. Anpassad JavaScript-kod krävs inte för att aktivera CORS.

Följande är ett exempel på en begäran om korsande ursprung från testknappen Värden till https://cors1.azurewebsites.net/api/values. Rubrik: Origin

• Tillhandahåller domänen för den webbplats som skickar begäran.
• Det är obligatoriskt och måste skilja sig från värden.

Allmänna rubriker

Request URL: https://cors1.azurewebsites.net/api/values
Request Method: GET
Status Code: 200 OK

Svarshuvuden

Content-Encoding: gzip
Content-Type: text/plain; charset=utf-8
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Transfer-Encoding: chunked
Vary: Accept-Encoding
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Connection: keep-alive
Host: cors1.azurewebsites.net
Origin: https://cors3.azurewebsites.net
Referer: https://cors3.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0 ...

Vid OPTIONS begäranden anger servern SvarshuvudenAccess-Control-Allow-Origin: {allowed origin} i svaret. I exempelkoden Delete [EnableCors] innehåller till exempel knappbegäran OPTIONS följande rubriker:

Allmänna rubriker

Request URL: https://cors3.azurewebsites.net/api/TodoItems2/MyDelete2/5
Request Method: OPTIONS
Status Code: 204 No Content

Svarshuvuden

Access-Control-Allow-Headers: Content-Type,x-custom-header
Access-Control-Allow-Methods: PUT,DELETE,GET,OPTIONS
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors3.azurewebsites.net
Vary: Origin
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Headers: content-type
Access-Control-Request-Method: DELETE
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/test?number=2
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

I de föregående svarshuvuden anger servern Access-Control-Allow-Origin headern i svaret. Värdet https://cors1.azurewebsites.net för den här rubriken matchar Origin rubriken i begäran.

Om AllowAnyOrigin anropas, Access-Control-Allow-Origin: *, returneras jokervärdet. AllowAnyOrigin tillåter valfritt ursprung.

Om svaret inte innehåller Access-Control-Allow-Origin huvud misslyckas begäran över ursprung. Mer specifikt tillåter webbläsaren inte begäran. Även om servern returnerar ett lyckat svar gör inte webbläsaren svaret tillgängligt för klientappen.

HTTP-omdirigering till HTTPS, orsakar ERR_INVALID_REDIRECT för CORS-förfrågan vid preflight-begäran.

Begäranden till en slutpunkt med HTTP som omdirigeras till HTTPS med UseHttpsRedirection misslyckas med ERR_INVALID_REDIRECT on the CORS preflight request.

API-projekt kan avvisa HTTP-begäranden i stället för att använda UseHttpsRedirection för att omdirigera begäranden till HTTPS.

CORS i IIS

När du distribuerar till IIS måste CORS köras före Windows-autentisering om servern inte är konfigurerad för att tillåta anonym åtkomst. För att stödja det här scenariot måste IIS CORS-modulen installeras och konfigureras för appen.

Testa CORS

Exempelnedladdningen har kod för att testa CORS. Se till hur du laddar ner. Exemplet är ett API-projekt med Razor sidor tillagda:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                    "http://www.contoso.com",
                    "https://cors1.azurewebsites.net",
                    "https://cors3.azurewebsites.net",
                    "https://localhost:44398",
                    "https://localhost:5001")
                .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();
app.MapRazorPages();

app.Run();

Följande ValuesController innehåller slutpunkterna för testning:

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

MyDisplayRouteInfo tillhandahålls av Rick.Docs.Samples.RouteInfo NuGet-paketet och visar väginformation.

Testa föregående exempelkod med någon av följande metoder:

• Kör exemplet med dotnet run och använd standard-URL:en https://localhost:5001.
• Kör exemplet från Visual Studio med porten inställd på 44398 för en URL till https://localhost:44398.

Använda en webbläsare med F12-verktygen:

• Välj knappen Värden och granska rubrikerna på fliken Nätverk .

• Välj knappen PUT-test . Mer information om hur du visar ALTERNATIV-begäran finns i Visa ALTERNATIV-begäranden . PUT-testet skapar två begäranden, en OPTIONS preflight-begäran och PUT-begäran.

• GetValues2 [DisableCors] Välj knappen för att utlösa en misslyckad CORS-begäran. Som nämnts i dokumentet returnerar svaret 200 lyckade resultat, men CORS-begäran görs inte. Välj fliken Konsol för att se CORS-felet. Beroende på webbläsaren visas ett fel som liknar följande:

  Åtkomst till att hämta 'https://cors1.azurewebsites.net/api/values/GetValues2' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Det finns ingen rubrik för "Access-Control-Allow-Origin" på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

CORS-aktiverade slutpunkter kan testas med ett verktyg, till exempel curl eller Fiddler. När du använder ett verktyg måste ursprunget för den begäran som anges av Origin rubriken skilja sig från den värd som tar emot begäran. Om begäran inte är korsdomän baserat på värdet av Origin header:

• CORS Middleware behöver inte bearbeta begäran.
• CORS-huvuden returneras inte i svaret.

Följande kommando använder curl för att utfärda en OPTIONS-begäran med information:

curl -X OPTIONS https://cors3.azurewebsites.net/api/TodoItems2/5 -i

Testa CORS med attributet [EnableCors] och RequireCors-metoden

Överväg följande kod som använder slutpunktsroutning för att aktivera CORS per slutpunkt med hjälp av RequireCors:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                    "http://www.contoso.com",
                    "https://cors1.azurewebsites.net",
                    "https://cors3.azurewebsites.net",
                    "https://localhost:44398",
                    "https://localhost:5001")
                .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/echo",
        context => context.Response.WriteAsync("echo"))
        .RequireCors("MyPolicy");

    endpoints.MapControllers();
    endpoints.MapRazorPages();
});

app.Run();

Observera att endast /echo slutpunkten använder RequireCors för att tillåta begäranden mellan ursprung med den angivna principen. Kontrollanterna nedan aktiverar CORS med hjälp av attributet [EnableCors].

Följande TodoItems1Controller innehåller slutpunkter för testning:

[Route("api/[controller]")]
[ApiController]
public class TodoItems1Controller : ControllerBase 
{
    // PUT: api/TodoItems1/5
    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id) {
        if (id < 1) {
            return Content($"ID = {id}");
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // Delete: api/TodoItems1/5
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // GET: api/TodoItems1
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors("MyPolicy")]
    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    // Delete: api/TodoItems1/MyDelete2/5
    [EnableCors("MyPolicy")]
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Knapparna Ta bort [EnableCors] och GET [EnableCors] lyckas, eftersom slutpunkterna har [EnableCors] och svarar på preflight-frågor. De andra slutpunkterna misslyckas. GET-knappen misslyckas eftersom JavaScript skickar:

 headers: {
      "Content-Type": "x-custom-header"
 },

Följande TodoItems2Controller innehåller liknande slutpunkter, men innehåller explicit kod för att svara på OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // [EnableCors] // Not needed as OPTIONS path provided.
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // [EnableCors] //  Warning ASP0023 Route '{id}' conflicts with another action route.
    //                  An HTTP request that matches multiple routes results in an ambiguous
    //                  match error.
    [EnableCors("MyPolicy")] // Required for this path.
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors("MyPolicy")]  // Required for this path.
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Föregående kod kan testas genom att distribuera exemplet till Azure. I listrutan Kontrollant väljer du Preflight och sedan Ange styrenhet. Alla CORS-anrop till slutpunkterna TodoItems2Controller lyckas.

Ytterligare resurser

• Resursdelning mellan ursprung (CORS)
• Konfigurationsreferens för IIS CORS-modul

Av Rick Anderson och Kirk Larkin

Den här artikeln visar hur du aktiverar CORS i en ASP.NET Core-app.

Webbläsarsäkerhet hindrar en webbsida från att göra begäranden till en annan domän än den som hanterade webbsidan. Den här begränsningen kallas principen för samma ursprung. Principen för samma ursprung förhindrar att en skadlig webbplats läser känsliga data från en annan webbplats. Ibland kanske du vill tillåta att andra webbplatser gör cross-origin-förfrågningar till din app. Mer information finns i artikeln Mozilla CORS.

Resursdelning mellan ursprung (CORS):

• Är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
• Är inte en säkerhetsfunktion, CORS slappnar av säkerheten. Ett API är inte säkrare genom att tillåta CORS. Mer information finns i Så här fungerar CORS.
• Tillåter att en server uttryckligen tillåter vissa begäranden mellan ursprung samtidigt som andra avvisas.
• Är säkrare och mer flexibelt än tidigare tekniker, till exempel JSONP.

Visa eller ladda ned exempelkod (hur du laddar ned)

Samma ursprung

Två URL:er har samma ursprung om de har identiska scheman, värdar och portar (RFC 6454).

Dessa två URL:er har samma ursprung:

• https://example.com/foo.html
• https://example.com/bar.html

Dessa URL:er har olika ursprung än de föregående två URL:erna:

• https://example.net: Olika domän
• https://www.example.com/foo.html: Olika underdomäner
• http://example.com/foo.html: Olika schema
• https://example.com:9000/foo.html: Annorlunda port

Aktivera CORS

Det finns tre sätt att aktivera CORS:

• I mellanprogram med hjälp av en namngiven princip eller standardprincip.
• Använda slutpunktsroutning.
• Med attributet [EnableCors] .

Med attributet [EnableCors] med en namngiven princip får du den bästa kontrollen när det gäller att begränsa slutpunkter som stöder CORS.

Varje metod beskrivs i följande avsnitt.

CORS med namngiven princip och mellanprogram

CORS Middleware hanterar ursprungsöverskridande begäranden. Följande kod tillämpar en CORS-princip på alla appens slutpunkter med angivet ursprung:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod:

• Anger principnamnet till _myAllowSpecificOrigins. Principnamnet är godtyckligt.
• UseCors Anropar tilläggsmetoden och anger _myAllowSpecificOrigins CORS-principen. UseCors lägger till CORS-mellanprogrammet. Anropet till UseCors måste placeras efter UseRouting, men före UseAuthorization. Mer information finns i Mellanprogramvaruordning.
• Anropar AddCors med ett lambda-uttryck. Lambda tar ett CorsPolicyBuilder objekt. Konfigurationsalternativ, till exempel WithOrigins, beskrivs senare i den här artikeln.
• _myAllowSpecificOrigins Aktiverar CORS-principen för alla kontrollantslutpunkter. Se Slutpunktsroutning för att tillämpa en CORS-princip på specifika slutpunkter.
• När du använder Mellanprogramvara för svarscachelagring anropar du UseCors före UseResponseCaching.

Med slutpunktsroutning måste CORS-mellanprogrammet konfigureras för att köras mellan anropen till UseRouting och UseEndpoints.

Metodanropet AddCors lägger till CORS-tjänster i appens tjänstcontainer:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Mer information finns i CORS-principalternativ i det här dokumentet.

Metoderna CorsPolicyBuilder kan länkas, enligt följande kod:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(MyAllowSpecificOrigins,
                          policy =>
                          {
                              policy.WithOrigins("http://example.com",
                                                  "http://www.contoso.com")
                                                  .AllowAnyHeader()
                                                  .AllowAnyMethod();
                          });
});

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Obs! Den angivna URL:en får inte innehålla ett avslutande snedstreck (/). Om URL:en avslutas med /, returneras false och ingen header returneras.

Ordning för UseCors och UseStaticFiles

UseStaticFiles Anropas vanligtvis före UseCors. Appar som använder JavaScript för att hämta statiska filer mellan webbplatser måste anropas UseCors före UseStaticFiles.

CORS med standardprincip och mellanprogram

Följande markerade kod aktiverar standardprincipen för CORS:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod tillämpar cors-standardprincipen på alla kontrollantslutpunkter.

Aktivera Cors med slutpunktsroutning

Med slutpunktsroutning kan CORS aktiveras per slutpunkt med hjälp RequireCors av uppsättningen med tilläggsmetoder:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/echo",
        context => context.Response.WriteAsync("echo"))
        .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapControllers()
             .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapGet("/echo2",
        context => context.Response.WriteAsync("echo2"));

    endpoints.MapRazorPages();
});

app.Run();

I koden ovan:

• app.UseCors aktiverar CORS-mellanprogrammet. Eftersom en standardprincip inte har konfigurerats, aktiverar inte app.UseCors() ensam CORS.
• /echo och kontrollerändpunkterna tillåter begäranden över ursprungsgränser enligt den angivna policyn.
• Slutpunkterna /echo2 och Razor Pages tillåter inte begäranden mellan ursprung eftersom ingen standardprincip har angetts.

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning med RequireCors.

I .NET 7 måste [EnableCors]-attributet skicka en parameter, annars genereras en varning ASP0023 från en tvetydig träff på rutten. .NET 8 eller senare genererar inte varningen ASP0023 .

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // [EnableCors] // Not needed as OPTIONS path provided.
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // [EnableCors] //  Warning ASP0023 Route '{id}' conflicts with another action route.
    //                  An HTTP request that matches multiple routes results in an ambiguous
    //                  match error.
    [EnableCors("MyPolicy")] // Required for this path.
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors("MyPolicy")]  // Required for this path.
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Se Testa CORS med attributet [EnableCors] och RequireCors-metoden för instruktioner om att testa kod som liknar föregående.

Aktivera CORS med attribut

Att aktivera CORS med attributet [EnableCors] och tillämpa en namngiven princip på endast de slutpunkter som kräver CORS ger den bästa kontrollen.

Attributet [EnableCors] är ett alternativ till att tillämpa CORS globalt. Attributet [EnableCors] aktiverar CORS för valda slutpunkter i stället för alla slutpunkter:

• [EnableCors] anger standardprincipen.
• [EnableCors("{Policy String}")] anger en namngiven princip.

Attributet [EnableCors] kan tillämpas på:

• Razor Sida PageModel
• Controller
• Kontrollantåtgärdsmetod

Olika principer kan tillämpas på kontrollanter, sidmodeller eller åtgärdsmetoder med attributet [EnableCors] . [EnableCors] När attributet tillämpas på en kontrollant, sidmodell eller åtgärdsmetod, och CORS är aktiverat i mellanprogram, tillämpas båda principerna. Vi rekommenderar att du inte kombinerar principer. Använd [EnableCors] attribut eller mellanprogram, inte båda i samma app.

Följande kod tillämpar en annan princip på varje metod:

[Route("api/[controller]")]
[ApiController]
public class WidgetController : ControllerBase
{
    // GET api/values
    [EnableCors("AnotherPolicy")]
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "green widget", "red widget" };
    }

    // GET api/values/5
    [EnableCors("Policy1")]
    [HttpGet("{id}")]
    public ActionResult<string> Get(int id)
    {
        return id switch
        {
            1 => "green widget",
            2 => "red widget",
            _ => NotFound(),
        };
    }
}

Följande kod skapar två CORS-principer:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("Policy1",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });

    options.AddPolicy("AnotherPolicy",
        policy =>
        {
            policy.WithOrigins("http://www.contoso.com")
                                .AllowAnyHeader()
                                .AllowAnyMethod();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

För den bästa kontrollen av att begränsa CORS-begäranden:

• Använd [EnableCors("MyPolicy")] med en namngiven princip.
• Definiera inte en standardprincip.
• Använd inte slutpunktsroutning.

Koden i nästa avsnitt uppfyller föregående lista.

Inaktivera CORS

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning.

Följande kod definierar CORS-principen "MyPolicy":

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com")
                    .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints => {
    endpoints.MapControllers();
    endpoints.MapRazorPages();
});

app.Run();

Följande kod inaktiverar CORS för åtgärden GetValues2 :

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

Föregående kod:

• Aktiverar inte CORS med slutpunktsroutning.
• Definierar inte någon CORS-standardprincip.
• Använder [EnableCors("MyPolicy")] för att aktivera "MyPolicy" CORS-principen för kontrollanten.
• Inaktiverar CORS för GetValues2 metoden.

Mer information om hur du testar koden ovan finns i Testa CORS .

Alternativ för CORS-policy

I det här avsnittet beskrivs de olika alternativ som kan anges i en CORS-princip:

• Ange de tillåtna ursprungen
• Ange tillåtna HTTP-metoder
• Ange de tillåtna begäranderubrikerna
• Ange de synliga svarshuvudena
• Autentiseringsuppgifter i begäranden mellan ursprung
• Ange förtidsförfallotiden

AddPolicy anropas i Program.cs. För vissa alternativ kan det vara bra att läsa avsnittet Hur CORS fungerar först.

Ange de tillåtna ursprungen

AllowAnyOrigin: Tillåter CORS-begäranden från alla ursprung med valfritt schema (http eller https). AllowAnyOrigin är osäker eftersom vilken som helst webbplats kan göra korsursprungsbegäranden till appen.

AllowAnyOrigin påverkar preflightbegäranden och Access-Control-Allow-Origin huvud. Mer information finns i avsnittet Preflight-begäranden .

SetIsOriginAllowedToAllowWildcardSubdomains: Anger IsOriginAllowed att principens egenskap ska vara en funktion som tillåter att ursprung matchar en konfigurerad jokerteckendomän när du utvärderar om ursprunget tillåts.

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://example.com")
                .SetIsOriginAllowedToAllowWildcardSubdomains();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

I föregående kod, SetIsOriginAllowedToAllowWildcardSubdomains anropas med basursprunget "https://example.com". Den här konfigurationen tillåter CORS-begäranden från alla underdomäner i example.com, till exempel https://subdomain.example.com eller https://api.example.com. Jokerteckenmatchningen hanteras av metoden, så ursprunget ska anges utan * jokertecknet.

Ange tillåtna HTTP-metoder

AllowAnyMethod:

• Tillåter alla HTTP-metoder:
• Påverkar preflight-begäranden och Access-Control-Allow-Methods headern. Mer information finns i avsnittet Preflight-begäranden .

Ange de tillåtna begäranderubrikerna

Om du vill tillåta att specifika rubriker skickas i en CORS-begäran, kallad förfrågningsrubriker, anropar du WithHeaders och anger de tillåtna rubrikerna:

using Microsoft.Net.Http.Headers;

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
       policy =>
       {
           policy.WithOrigins("http://example.com")
                  .WithHeaders(HeaderNames.ContentType, "x-custom-header");
       });
});

builder.Services.AddControllers();

var app = builder.Build();

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

AllowAnyHeader påverkar preflight-begäranden och 'Access-Control-Request-Headers'-headern. Mer information finns i avsnittet Preflight-begäranden .

En matchning av CORS Middleware-policy mot specifika rubriker som specificeras av WithHeaders är endast möjlig när rubrikerna som skickas i Access-Control-Request-Headers exakt matchar de rubriker som anges i WithHeaders.

Anta till exempel att en app har konfigurerats på följande sätt:

app.UseCors(policy => policy.WithHeaders(HeaderNames.CacheControl));

CORS Middleware nekar en förhandsbegäran med följande begärandehuvud eftersom Content-Language (HeaderNames.ContentLanguage) inte visas i WithHeaders:

Access-Control-Request-Headers: Cache-Control, Content-Language

Appen returnerar ett 200 OK-svar men skickar inte CORS-huvudena tillbaka. Därför försöker inte webbläsaren skicka begäran om korsande ursprung.

Ange de synliga svarshuvudena

Som standardinställning exponerar inte webbläsaren alla svarshuvuden till appen. Mer information finns i Resursdelning mellan ursprung i W3C (terminologi): Enkelt svarshuvud.

Svarshuvudena som är tillgängliga som standard är:

• Cache-Control
• Content-Language
• Content-Type
• Expires
• Last-Modified
• Pragma

CORS-specifikationen kallar dessa rubriker enkla svarsrubriker. Om du vill göra andra rubriker tillgängliga för appen anropar du WithExposedHeaders:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyExposeResponseHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .WithExposedHeaders("x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Autentiseringsuppgifter i begäranden mellan ursprung

Autentiseringsuppgifter kräver särskild hantering i en CORS-begäran. Som standard skickar webbläsaren inte autentiseringsuppgifter med en begäran om korsande ursprung. Autentiseringsuppgifterna omfattar cookies och HTTP-autentiseringsscheman. Om du vill skicka autentiseringsuppgifter med en begäran om korsande ursprung måste klienten ange XMLHttpRequest.withCredentials till true.

Använder XMLHttpRequest direkt:

var xhr = new XMLHttpRequest();
xhr.open('get', 'https://www.example.com/api/test');
xhr.withCredentials = true;

Använda jQuery:

$.ajax({
  type: 'get',
  url: 'https://www.example.com/api/test',
  xhrFields: {
    withCredentials: true
  }
});

Använda Fetch API:

fetch('https://www.example.com/api/test', {
    credentials: 'include'
});

Servern måste tillåta autentiseringsuppgifterna. Om du vill tillåta autentiseringsuppgifter mellan ursprung anropar du AllowCredentials:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyMyAllowCredentialsPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .AllowCredentials();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

HTTP-svaret innehåller en Access-Control-Allow-Credentials rubrik som talar om för webbläsaren att servern tillåter autentiseringsuppgifter för en begäran om korsande ursprung.

Om webbläsaren skickar autentiseringsuppgifter men svaret inte innehåller ett giltigt Access-Control-Allow-Credentials huvud exponerar inte webbläsaren svaret för appen och begäran om korsande ursprung misslyckas.

Att tillåta autentiseringsuppgifter mellan ursprung är en säkerhetsrisk. En webbplats på en annan domän kan skicka en inloggad användares autentiseringsuppgifter till appen för användarens räkning utan användarens vetskap.

CORS-specifikationen anger också att att ställa in ursprung till "*" (alla ursprung) är ogiltig om Access-Control-Allow-Credentials headern finns.

Preflight-begäranden

För vissa CORS-begäranden skickar webbläsaren ytterligare en OPTIONS-begäran innan den faktiska begäran görs. Den här begäran kallas för en preflight-begäran. Webbläsaren kan hoppa över preflight-begäran om alla följande villkor är uppfyllda:

• Begärandemetoden är GET, HEAD eller POST.
• Appen anger inte andra begärandehuvuden än Accept, Accept-Language, Content-Language, Content-Typeeller Last-Event-ID.
• Rubriken Content-Type , om den anges, har något av följande värden:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Regeln för begärandehuvuden som angetts för klientbegäran gäller för rubriker som appen anger genom att anropa setRequestHeaderXMLHttpRequest objektet. CORS-specifikationen kallar dessa rubriker förfrågningsrubriker från författare. Regeln gäller inte för rubriker som webbläsaren kan ange, till exempel User-Agent, Hosteller Content-Length.

Följande är ett exempelsvar som liknar preflight-begäran från knappen [Put test] i avsnittet Test CORS i det här dokumentet.

General:
Request URL: https://cors3.azurewebsites.net/api/values/5
Request Method: OPTIONS
Status Code: 204 No Content

Response Headers:
Access-Control-Allow-Methods: PUT,DELETE,GET
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f8...8;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Vary: Origin

Request Headers:
Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Method: PUT
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

Preflight-begäran använder metoden HTTP OPTIONS . Den kan innehålla följande rubriker:

• Access-Control-Request-Method: DEN HTTP-metod som ska användas för den faktiska begäran.
• Access-Control-Request-Headers: En lista över begärandehuvuden som appen anger för den faktiska begäran. Som tidigare nämnts innehåller detta inte rubriker som webbläsaren anger, till exempel User-Agent.
• Access-Control-Allow-Methods

Om preflight-begäran nekas returnerar appen ett 200 OK svar men anger inte CORS-huvudena. Därför försöker inte webbläsaren skicka begäran om korsande ursprung. Ett exempel på en nekad preflight-begäran finns i avsnittet Testa CORS i det här dokumentet.

Med hjälp av F12-verktygen visar konsolappen ett fel som liknar något av följande, beroende på webbläsaren:

• Firefox: Begäran om korsande ursprung blockerad: Samma ursprungsprincip tillåter inte läsning av fjärrresursen på https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5. (Orsak: CORS-begäran lyckades inte). Lära sig mer
• Chromium-baserad: Åtkomst till fetch vid 'https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Svaret på förhandsbegäran passerar inte åtkomstkontrollen: Inget "Access-Control-Allow-Origin"-huvud finns på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

Om du vill tillåta specifika rubriker anropar du WithHeaders:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowHeadersPolicy",
        policy =>
        {
        policy.WithOrigins("http://example.com")
                   .WithHeaders(HeaderNames.ContentType, "x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowAllHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Webbläsare är inte konsekventa i hur de anger Access-Control-Request-Headers. Om något av följande:

• Rubriker är inställda på något annat än "*"
• AllowAnyHeader heter: Inkludera minst Accept, Content-Typeoch Origin, plus alla anpassade rubriker som du vill stödja.

Automatisk kod för förhandsbegäran

När CORS-principen antingen tillämpas:

• Globalt genom att anropa app.UseCors i Program.cs.
• Använda attributet [EnableCors] .

ASP.NET Core svarar på preflight OPTIONS-begäran.

Avsnittet Test CORS i det här dokumentet visar det här beteendet.

[HttpOptions]-attribut för preflight-begäranden

När CORS är aktiverat med rätt princip svarar ASP.NET Core vanligtvis på CORS-förhandsbegäranden automatiskt.

Följande kod använder attributet [HttpOptions] för att skapa slutpunkter för OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

Mer information om hur du testar koden ovan finns i Testa CORS med attributet [EnableCors] och RequireCors-metoden .

Ange förtidsförfallotiden

Rubriken Access-Control-Max-Age anger hur länge svaret på preflight-begäran kan cachelagras. Om du vill ange den här rubriken anropar du SetPreflightMaxAge:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MySetPreflightExpirationPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .SetPreflightMaxAge(TimeSpan.FromSeconds(2520));
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Aktivera CORS på en slutpunkt

Så här fungerar CORS

I det här avsnittet beskrivs vad som händer i en CORS-begäran på HTTP-meddelandenas nivå.

• CORS är inte en säkerhetsfunktion. CORS är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
  • En illasinnad aktör kan till exempel använda XSS (Cross-Site Scripting) mot din webbplats och köra en begäran mellan platser till deras CORS-aktiverade webbplats för att stjäla information.
• Ett API är inte säkrare genom att tillåta CORS.
  • Det är upp till klienten (webbläsaren) att framtvinga CORS. Servern kör begäran och returnerar svaret. Det är klienten som returnerar ett fel och blockerar svaret. Något av följande verktyg visar till exempel serversvaret:
    • Fiddler
    • .NET HttpClient
    • En webbläsare genom att ange URL:en i adressfältet.
• Det är ett sätt för en server att tillåta webbläsare att köra en XHR - eller Fetch API-begäran mellan ursprung som annars skulle vara förbjuden.
  • Webbläsare utan CORS kan inte göra begäranden mellan ursprung. Före CORS användes JSONP för att kringgå denna begränsning. JSONP använder inte XHR, den använder taggen <script> för att ta emot svaret. Skript tillåts att laddas från olika ursprung.

CORS-specifikationen introducerade flera nya HTTP-huvuden som möjliggör begäranden mellan ursprung. Om en webbläsare stöder CORS anger den dessa huvuden automatiskt för begäranden mellan olika ursprung. Anpassad JavaScript-kod krävs inte för att aktivera CORS.

Välj knappen PUT-test i det distribuerade exemplet. Rubrik: Origin

• Tillhandahåller domänen för den webbplats som skickar begäran.
• Det är obligatoriskt och måste skilja sig från värden.

Allmänna rubriker

Request URL: https://cors1.azurewebsites.net/api/values
Request Method: GET
Status Code: 200 OK

Svarshuvuden

Content-Encoding: gzip
Content-Type: text/plain; charset=utf-8
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Transfer-Encoding: chunked
Vary: Accept-Encoding
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Connection: keep-alive
Host: cors1.azurewebsites.net
Origin: https://cors3.azurewebsites.net
Referer: https://cors3.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0 ...

Vid OPTIONS begäranden anger servern SvarshuvudenAccess-Control-Allow-Origin: {allowed origin} i svaret. I exempelkoden Delete [EnableCors] innehåller till exempel knappbegäran OPTIONS följande rubriker:

Allmänna rubriker

Request URL: https://cors3.azurewebsites.net/api/TodoItems2/MyDelete2/5
Request Method: OPTIONS
Status Code: 204 No Content

Svarshuvuden

Access-Control-Allow-Headers: Content-Type,x-custom-header
Access-Control-Allow-Methods: PUT,DELETE,GET,OPTIONS
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors3.azurewebsites.net
Vary: Origin
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Headers: content-type
Access-Control-Request-Method: DELETE
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/test?number=2
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

I de föregående svarshuvuden anger servern Access-Control-Allow-Origin headern i svaret. Värdet https://cors1.azurewebsites.net för den här rubriken matchar Origin rubriken i begäran.

Om AllowAnyOrigin anropas, Access-Control-Allow-Origin: *, returneras jokervärdet. AllowAnyOrigin tillåter valfritt ursprung.

Om svaret inte innehåller Access-Control-Allow-Origin huvud misslyckas begäran över ursprung. Mer specifikt tillåter webbläsaren inte begäran. Även om servern returnerar ett lyckat svar gör inte webbläsaren svaret tillgängligt för klientappen.

HTTP-omdirigering till HTTPS, orsakar ERR_INVALID_REDIRECT för CORS-förfrågan vid preflight-begäran.

Begäranden till en slutpunkt med HTTP som omdirigeras till HTTPS med UseHttpsRedirection misslyckas med ERR_INVALID_REDIRECT on the CORS preflight request.

API-projekt kan avvisa HTTP-begäranden i stället för att använda UseHttpsRedirection för att omdirigera begäranden till HTTPS.

CORS i IIS

När du distribuerar till IIS måste CORS köras före Windows-autentisering om servern inte är konfigurerad för att tillåta anonym åtkomst. För att stödja det här scenariot måste IIS CORS-modulen installeras och konfigureras för appen.

Testa CORS

Exempelnedladdningen har kod för att testa CORS. Se till hur du laddar ner. Exemplet är ett API-projekt med Razor sidor tillagda:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                    "http://www.contoso.com",
                    "https://cors1.azurewebsites.net",
                    "https://cors3.azurewebsites.net",
                    "https://localhost:44398",
                    "https://localhost:5001")
                .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();
app.MapRazorPages();

app.Run();

Följande ValuesController innehåller slutpunkterna för testning:

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

MyDisplayRouteInfo tillhandahålls av Rick.Docs.Samples.RouteInfo NuGet-paketet och visar väginformation.

Testa föregående exempelkod med någon av följande metoder:

• Kör exemplet med dotnet run och använd standard-URL:en https://localhost:5001.
• Kör exemplet från Visual Studio med porten inställd på 44398 för en URL till https://localhost:44398.

Använda en webbläsare med F12-verktygen:

• Välj knappen Värden och granska rubrikerna på fliken Nätverk .

• Välj knappen PUT-test . Mer information om hur du visar ALTERNATIV-begäran finns i Visa ALTERNATIV-begäranden . PUT-testet skapar två begäranden, en OPTIONS preflight-begäran och PUT-begäran.

• GetValues2 [DisableCors] Välj knappen för att utlösa en misslyckad CORS-begäran. Som nämnts i dokumentet returnerar svaret 200 lyckade resultat, men CORS-begäran görs inte. Välj fliken Konsol för att se CORS-felet. Beroende på webbläsaren visas ett fel som liknar följande:

  Åtkomst till att hämta 'https://cors1.azurewebsites.net/api/values/GetValues2' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Det finns ingen rubrik för "Access-Control-Allow-Origin" på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

CORS-aktiverade slutpunkter kan testas med ett verktyg, till exempel curl eller Fiddler. När du använder ett verktyg måste ursprunget för den begäran som anges av Origin rubriken skilja sig från den värd som tar emot begäran. Om begäran inte är korsdomän baserat på värdet av Origin header:

• CORS Middleware behöver inte bearbeta begäran.
• CORS-huvuden returneras inte i svaret.

Följande kommando använder curl för att utfärda en OPTIONS-begäran med information:

curl -X OPTIONS https://cors3.azurewebsites.net/api/TodoItems2/5 -i

Testa CORS med attributet [EnableCors] och RequireCors-metoden

Överväg följande kod som använder slutpunktsroutning för att aktivera CORS per slutpunkt med hjälp av RequireCors:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                    "http://www.contoso.com",
                    "https://cors1.azurewebsites.net",
                    "https://cors3.azurewebsites.net",
                    "https://localhost:44398",
                    "https://localhost:5001")
                .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/echo",
        context => context.Response.WriteAsync("echo"))
        .RequireCors("MyPolicy");

    endpoints.MapControllers();
    endpoints.MapRazorPages();
});

app.Run();

Observera att endast /echo slutpunkten använder RequireCors för att tillåta begäranden mellan ursprung med den angivna principen. Kontrollanterna nedan aktiverar CORS med hjälp av attributet [EnableCors].

Följande TodoItems1Controller innehåller slutpunkter för testning:

[Route("api/[controller]")]
[ApiController]
public class TodoItems1Controller : ControllerBase 
{
    // PUT: api/TodoItems1/5
    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id) {
        if (id < 1) {
            return Content($"ID = {id}");
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // Delete: api/TodoItems1/5
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // GET: api/TodoItems1
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors("MyPolicy")]
    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    // Delete: api/TodoItems1/MyDelete2/5
    [EnableCors("MyPolicy")]
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Knapparna Ta bort [EnableCors] och GET [EnableCors] lyckas, eftersom slutpunkterna har [EnableCors] och svarar på preflight-frågor. De andra slutpunkterna misslyckas. GET-knappen misslyckas eftersom JavaScript skickar:

 headers: {
      "Content-Type": "x-custom-header"
 },

Följande TodoItems2Controller innehåller liknande slutpunkter, men innehåller explicit kod för att svara på OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // [EnableCors] // Not needed as OPTIONS path provided.
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // [EnableCors] //  Warning ASP0023 Route '{id}' conflicts with another action route.
    //                  An HTTP request that matches multiple routes results in an ambiguous
    //                  match error.
    [EnableCors("MyPolicy")] // Required for this path.
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors("MyPolicy")]  // Required for this path.
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Föregående kod kan testas genom att distribuera exemplet till Azure. I listrutan Styrenhet, välj Preflight och sedan Ange styrenhet. Alla CORS-anrop till slutpunkterna TodoItems2Controller lyckas.

Ytterligare resurser

• Resursdelning mellan ursprung (CORS)
• Konfigurationsreferens för IIS CORS-modul

Av Rick Anderson och Kirk Larkin

Den här artikeln visar hur du aktiverar CORS i en ASP.NET Core-app.

Webbläsarsäkerhet hindrar en webbsida från att göra begäranden till en annan domän än den som hanterade webbsidan. Den här begränsningen kallas principen för samma ursprung. Principen för samma ursprung förhindrar att en skadlig webbplats läser känsliga data från en annan webbplats. Ibland kanske du vill tillåta att andra webbplatser gör cross-origin-förfrågningar till din app. Mer information finns i artikeln Mozilla CORS.

Resursdelning mellan ursprung (CORS):

• Är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
• Är inte en säkerhetsfunktion, CORS slappnar av säkerheten. Ett API är inte säkrare genom att tillåta CORS. Mer information finns i Så här fungerar CORS.
• Tillåter att en server uttryckligen tillåter vissa begäranden mellan ursprung samtidigt som andra avvisas.
• Är säkrare och mer flexibelt än tidigare tekniker, till exempel JSONP.

Visa eller ladda ned exempelkod (hur du laddar ned)

Samma ursprung

Två URL:er har samma ursprung om de har identiska scheman, värdar och portar (RFC 6454).

Dessa två URL:er har samma ursprung:

• https://example.com/foo.html
• https://example.com/bar.html

Dessa URL:er har olika ursprung än de föregående två URL:erna:

• https://example.net: Olika domän
• https://www.example.com/foo.html: Olika underdomäner
• http://example.com/foo.html: Olika schema
• https://example.com:9000/foo.html: Annorlunda port

Aktivera CORS

Det finns tre sätt att aktivera CORS:

• I mellanprogram med hjälp av en namngiven princip eller standardprincip.
• Använda slutpunktsroutning.
• Med attributet [EnableCors] .

Med attributet [EnableCors] med en namngiven princip får du den bästa kontrollen när det gäller att begränsa slutpunkter som stöder CORS.

Varje metod beskrivs i följande avsnitt.

CORS med namngiven princip och mellanprogram

CORS Middleware hanterar ursprungsöverskridande begäranden. Följande kod tillämpar en CORS-princip på alla appens slutpunkter med angivet ursprung:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod:

• Anger principnamnet till _myAllowSpecificOrigins. Principnamnet är godtyckligt.
• UseCors Anropar tilläggsmetoden och anger _myAllowSpecificOrigins CORS-principen. UseCors lägger till CORS-mellanprogrammet. Anropet till UseCors måste placeras efter UseRouting, men före UseAuthorization. Mer information finns i Mellanprogramvaruordning.
• Anropar AddCors med ett lambda-uttryck. Lambda tar ett CorsPolicyBuilder objekt. Konfigurationsalternativ, till exempel WithOrigins, beskrivs senare i den här artikeln.
• _myAllowSpecificOrigins Aktiverar CORS-principen för alla kontrollantslutpunkter. Se Slutpunktsroutning för att tillämpa en CORS-princip på specifika slutpunkter.
• När du använder Mellanprogramvara för svarscachelagring anropar du UseCors före UseResponseCaching.

Med slutpunktsroutning måste CORS-mellanprogrammet konfigureras för att köras mellan anropen till UseRouting och UseEndpoints.

Metodanropet AddCors lägger till CORS-tjänster i appens tjänstcontainer:

var  MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy  =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

// services.AddResponseCaching();

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Mer information finns i CORS-principalternativ i det här dokumentet.

Metoderna CorsPolicyBuilder kan länkas, enligt följande kod:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(MyAllowSpecificOrigins,
                          policy =>
                          {
                              policy.WithOrigins("http://example.com",
                                                  "http://www.contoso.com")
                                                  .AllowAnyHeader()
                                                  .AllowAnyMethod();
                          });
});

builder.Services.AddControllers();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors(MyAllowSpecificOrigins);

app.UseAuthorization();

app.MapControllers();

app.Run();

Obs! Den angivna URL:en får inte innehålla ett avslutande snedstreck (/). Om URL:en avslutas med /, returneras false och ingen header returneras.

Ordning för UseCors och UseStaticFiles

UseStaticFiles Anropas vanligtvis före UseCors. Appar som använder JavaScript för att hämta statiska filer mellan webbplatser måste anropas UseCors före UseStaticFiles.

CORS med standardprincip och mellanprogram

Följande markerade kod aktiverar standardprincipen för CORS:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

Föregående kod tillämpar cors-standardprincipen på alla kontrollantslutpunkter.

Aktivera Cors med slutpunktsroutning

Aktivering av CORS per slutpunkt med hjälp av RequireCorsstöder inte automatiska förhandsbegäranden. Mer information finns i det här GitHub-problemet och Testa CORS med slutpunktsroutning och [HttpOptions].

Med slutpunktsroutning kan CORS aktiveras per slutpunkt med hjälp RequireCors av uppsättningen med tilläggsmetoder:

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      policy =>
                      {
                          policy.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/echo",
        context => context.Response.WriteAsync("echo"))
        .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapControllers()
             .RequireCors(MyAllowSpecificOrigins);

    endpoints.MapGet("/echo2",
        context => context.Response.WriteAsync("echo2"));

    endpoints.MapRazorPages();
});

app.Run();

I koden ovan:

• app.UseCors aktiverar CORS-mellanprogrammet. Eftersom en standardprincip inte har konfigurerats, aktiverar inte app.UseCors() ensam CORS.
• /echo och kontrollerändpunkterna tillåter begäranden över ursprungsgränser enligt den angivna policyn.
• Slutpunkterna /echo2 och Razor Pages tillåter inte begäranden mellan ursprung eftersom ingen standardprincip har angetts.

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning med RequireCors.

Se Testa CORS med slutpunktsroutning och [HttpOptions] för instruktioner om att testa kod som liknar föregående.

Aktivera CORS med attribut

Att aktivera CORS med attributet [EnableCors] och tillämpa en namngiven princip på endast de slutpunkter som kräver CORS ger den bästa kontrollen.

Attributet [EnableCors] är ett alternativ till att tillämpa CORS globalt. Attributet [EnableCors] aktiverar CORS för valda slutpunkter i stället för alla slutpunkter:

• [EnableCors] anger standardprincipen.
• [EnableCors("{Policy String}")] anger en namngiven princip.

Attributet [EnableCors] kan tillämpas på:

• Razor Sida PageModel
• Controller
• Kontrollantåtgärdsmetod

Olika principer kan tillämpas på kontrollanter, sidmodeller eller åtgärdsmetoder med attributet [EnableCors] . [EnableCors] När attributet tillämpas på en kontrollant, sidmodell eller åtgärdsmetod, och CORS är aktiverat i mellanprogram, tillämpas båda principerna. Vi rekommenderar att du inte kombinerar principer. Använd [EnableCors] attribut eller mellanprogram, inte båda i samma app.

Följande kod tillämpar en annan princip på varje metod:

[Route("api/[controller]")]
[ApiController]
public class WidgetController : ControllerBase
{
    // GET api/values
    [EnableCors("AnotherPolicy")]
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "green widget", "red widget" };
    }

    // GET api/values/5
    [EnableCors("Policy1")]
    [HttpGet("{id}")]
    public ActionResult<string> Get(int id)
    {
        return id switch
        {
            1 => "green widget",
            2 => "red widget",
            _ => NotFound(),
        };
    }
}

Följande kod skapar två CORS-principer:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("Policy1",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });

    options.AddPolicy("AnotherPolicy",
        policy =>
        {
            policy.WithOrigins("http://www.contoso.com")
                                .AllowAnyHeader()
                                .AllowAnyMethod();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();

app.Run();

För den bästa kontrollen av att begränsa CORS-begäranden:

• Använd [EnableCors("MyPolicy")] med en namngiven princip.
• Definiera inte en standardprincip.
• Använd inte slutpunktsroutning.

Koden i nästa avsnitt uppfyller föregående lista.

Inaktivera CORS

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning.

Följande kod definierar CORS-principen "MyPolicy":

var MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com",
                                "http://www.contoso.com")
                    .WithMethods("PUT", "DELETE", "GET");
        });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();
app.MapRazorPages();

app.Run();

Följande kod inaktiverar CORS för åtgärden GetValues2 :

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

Föregående kod:

• Aktiverar inte CORS med slutpunktsroutning.
• Definierar inte någon CORS-standardprincip.
• Använder [EnableCors("MyPolicy")] för att aktivera "MyPolicy" CORS-principen för kontrollanten.
• Inaktiverar CORS för GetValues2 metoden.

Mer information om hur du testar koden ovan finns i Testa CORS .

Alternativ för CORS-policy

I det här avsnittet beskrivs de olika alternativ som kan anges i en CORS-princip:

• Ange de tillåtna ursprungen
• Ange tillåtna HTTP-metoder
• Ange de tillåtna begäranderubrikerna
• Ange de synliga svarshuvudena
• Autentiseringsuppgifter i begäranden mellan ursprung
• Ange förtidsförfallotiden

AddPolicy anropas i Program.cs. För vissa alternativ kan det vara bra att läsa avsnittet Hur CORS fungerar först.

Ange de tillåtna ursprungen

AllowAnyOrigin: Tillåter CORS-begäranden från alla ursprung med valfritt schema (http eller https). AllowAnyOrigin är osäker eftersom vilken som helst webbplats kan göra korsursprungsbegäranden till appen.

AllowAnyOrigin påverkar preflightbegäranden och Access-Control-Allow-Origin huvud. Mer information finns i avsnittet Preflight-begäranden .

SetIsOriginAllowedToAllowWildcardSubdomains: Anger IsOriginAllowed att principens egenskap ska vara en funktion som tillåter att ursprung matchar en konfigurerad jokerteckendomän när du utvärderar om ursprunget tillåts.

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://example.com")
                .SetIsOriginAllowedToAllowWildcardSubdomains();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

I den föregående koden anropas SetIsOriginAllowedToAllowWildcardSubdomains med basursprunget "https://example.com". Den här konfigurationen tillåter CORS-begäranden från alla underdomäner i example.com, till exempel https://subdomain.example.com eller https://api.example.com. Jokerteckenmatchningen hanteras av metoden, så ursprunget ska anges utan * jokertecknet.

Ange tillåtna HTTP-metoder

AllowAnyMethod:

• Tillåter alla HTTP-metoder:
• Påverkar preflight-begäranden och Access-Control-Allow-Methods headern. Mer information finns i avsnittet Preflight-begäranden .

Ange de tillåtna begäranderubrikerna

Om du vill tillåta att specifika rubriker skickas i en CORS-begäran, kallad förfrågningsrubriker, anropar du WithHeaders och anger de tillåtna rubrikerna:

using Microsoft.Net.Http.Headers;

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
       policy =>
       {
           policy.WithOrigins("http://example.com")
                  .WithHeaders(HeaderNames.ContentType, "x-custom-header");
       });
});

builder.Services.AddControllers();

var app = builder.Build();

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

var MyAllowSpecificOrigins = "_MyAllowSubdomainPolicy";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

AllowAnyHeader påverkar preflight-begäranden och 'Access-Control-Request-Headers'-headern. Mer information finns i avsnittet Preflight-begäranden .

En matchning av CORS Middleware-policy mot specifika rubriker som specificeras av WithHeaders är endast möjlig när rubrikerna som skickas i Access-Control-Request-Headers exakt matchar de rubriker som anges i WithHeaders.

Anta till exempel att en app har konfigurerats på följande sätt:

app.UseCors(policy => policy.WithHeaders(HeaderNames.CacheControl));

CORS Middleware nekar en förhandsbegäran med följande begärandehuvud eftersom Content-Language (HeaderNames.ContentLanguage) inte visas i WithHeaders:

Access-Control-Request-Headers: Cache-Control, Content-Language

Appen returnerar ett 200 OK-svar men skickar inte CORS-huvudena tillbaka. Därför försöker inte webbläsaren skicka begäran om korsande ursprung.

Ange de synliga svarshuvudena

Som standardinställning exponerar inte webbläsaren alla svarshuvuden till appen. Mer information finns i Resursdelning mellan ursprung i W3C (terminologi): Enkelt svarshuvud.

Svarshuvudena som är tillgängliga som standard är:

• Cache-Control
• Content-Language
• Content-Type
• Expires
• Last-Modified
• Pragma

CORS-specifikationen kallar dessa rubriker enkla svarsrubriker. Om du vill göra andra rubriker tillgängliga för appen anropar du WithExposedHeaders:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyExposeResponseHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .WithExposedHeaders("x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Autentiseringsuppgifter i begäranden mellan ursprung

Autentiseringsuppgifter kräver särskild hantering i en CORS-begäran. Som standard skickar webbläsaren inte autentiseringsuppgifter med en begäran om korsande ursprung. Autentiseringsuppgifterna omfattar cookies och HTTP-autentiseringsscheman. Om du vill skicka autentiseringsuppgifter med en begäran om korsande ursprung måste klienten ange XMLHttpRequest.withCredentials till true.

Använder XMLHttpRequest direkt:

var xhr = new XMLHttpRequest();
xhr.open('get', 'https://www.example.com/api/test');
xhr.withCredentials = true;

Använda jQuery:

$.ajax({
  type: 'get',
  url: 'https://www.example.com/api/test',
  xhrFields: {
    withCredentials: true
  }
});

Använda Fetch API:

fetch('https://www.example.com/api/test', {
    credentials: 'include'
});

Servern måste tillåta autentiseringsuppgifterna. Om du vill tillåta autentiseringsuppgifter mellan ursprung anropar du AllowCredentials:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyMyAllowCredentialsPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .AllowCredentials();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

HTTP-svaret innehåller en Access-Control-Allow-Credentials rubrik som talar om för webbläsaren att servern tillåter autentiseringsuppgifter för en begäran om korsande ursprung.

Om webbläsaren skickar autentiseringsuppgifter men svaret inte innehåller ett giltigt Access-Control-Allow-Credentials huvud exponerar inte webbläsaren svaret för appen och begäran om korsande ursprung misslyckas.

Att tillåta autentiseringsuppgifter mellan ursprung är en säkerhetsrisk. En webbplats på en annan domän kan skicka en inloggad användares autentiseringsuppgifter till appen för användarens räkning utan användarens vetskap.

CORS-specifikationen anger också att att ställa in ursprung till "*" (alla ursprung) är ogiltig om Access-Control-Allow-Credentials headern finns.

Preflight-begäranden

För vissa CORS-begäranden skickar webbläsaren ytterligare en OPTIONS-begäran innan den faktiska begäran görs. Den här begäran kallas för en preflight-begäran. Webbläsaren kan hoppa över preflight-begäran om alla följande villkor är uppfyllda:

• Begärandemetoden är GET, HEAD eller POST.
• Appen anger inte andra begärandehuvuden än Accept, Accept-Language, Content-Language, Content-Typeeller Last-Event-ID.
• Rubriken Content-Type , om den anges, har något av följande värden:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Regeln för begärandehuvuden som angetts för klientbegäran gäller för rubriker som appen anger genom att anropa setRequestHeaderXMLHttpRequest objektet. CORS-specifikationen kallar dessa rubriker förfrågningsrubriker från författare. Regeln gäller inte för rubriker som webbläsaren kan ange, till exempel User-Agent, Hosteller Content-Length.

Följande är ett exempelsvar som liknar preflight-begäran från knappen [Put test] i avsnittet Test CORS i det här dokumentet.

General:
Request URL: https://cors3.azurewebsites.net/api/values/5
Request Method: OPTIONS
Status Code: 204 No Content

Response Headers:
Access-Control-Allow-Methods: PUT,DELETE,GET
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f8...8;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Vary: Origin

Request Headers:
Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Method: PUT
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

Preflight-begäran använder metoden HTTP OPTIONS . Den kan innehålla följande rubriker:

• Access-Control-Request-Method: DEN HTTP-metod som ska användas för den faktiska begäran.
• Access-Control-Request-Headers: En lista över begärandehuvuden som appen anger för den faktiska begäran. Som tidigare nämnts innehåller detta inte rubriker som webbläsaren anger, till exempel User-Agent.
• Access-Control-Allow-Methods

Om preflight-begäran nekas returnerar appen ett 200 OK svar men anger inte CORS-huvudena. Därför försöker inte webbläsaren skicka begäran om korsande ursprung. Ett exempel på en nekad preflight-begäran finns i avsnittet Testa CORS i det här dokumentet.

Med hjälp av F12-verktygen visar konsolappen ett fel som liknar något av följande, beroende på webbläsaren:

• Firefox: Begäran om korsande ursprung blockerad: Samma ursprungsprincip tillåter inte läsning av fjärrresursen på https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5. (Orsak: CORS-begäran lyckades inte). Lära sig mer
• Chromium-baserad: Åtkomst till fetch vid 'https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Svaret på förhandsbegäran passerar inte åtkomstkontrollen: Inget "Access-Control-Allow-Origin"-huvud finns på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

Om du vill tillåta specifika rubriker anropar du WithHeaders:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowHeadersPolicy",
        policy =>
        {
        policy.WithOrigins("http://example.com")
                   .WithHeaders(HeaderNames.ContentType, "x-custom-header");
        });
});

builder.Services.AddControllers();

var app = builder.Build();

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

using Microsoft.Net.Http.Headers;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MyAllowAllHeadersPolicy",
        policy =>
        {
            policy.WithOrigins("https://*.example.com")
                   .AllowAnyHeader();
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Webbläsare är inte konsekventa i hur de anger Access-Control-Request-Headers. Om något av följande:

• Rubriker är inställda på något annat än "*"
• AllowAnyHeader heter: Inkludera minst Accept, Content-Typeoch Origin, plus alla anpassade rubriker som du vill stödja.

Automatisk kod för förhandsbegäran

När CORS-principen antingen tillämpas:

• Globalt genom att anropa app.UseCors i Program.cs.
• Använda attributet [EnableCors] .

ASP.NET Core svarar på preflight OPTIONS-begäran.

Att aktivera CORS per slutpunkt med hjälp av RequireCors stöder för närvarande inte automatiska preflight-begäranden.

Avsnittet Test CORS i det här dokumentet visar det här beteendet.

[HttpOptions]-attribut för preflight-begäranden

När CORS är aktiverat med rätt princip svarar ASP.NET Core vanligtvis på CORS-förhandsbegäranden automatiskt. I vissa scenarier kanske detta inte är fallet. Du kan till exempel använda CORS med slutpunktsroutning.

Följande kod använder attributet [HttpOptions] för att skapa slutpunkter för OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

Se Testa CORS med slutpunktsroutning och [HttpOptions] för instruktioner om hur du testar föregående kod.

Ange förtidsförfallotiden

Rubriken Access-Control-Max-Age anger hur länge svaret på preflight-begäran kan cachelagras. Om du vill ange den här rubriken anropar du SetPreflightMaxAge:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy("MySetPreflightExpirationPolicy",
        policy =>
        {
            policy.WithOrigins("http://example.com")
                   .SetPreflightMaxAge(TimeSpan.FromSeconds(2520));
        });
});

builder.Services.AddControllers();

var app = builder.Build();

Så här fungerar CORS

I det här avsnittet beskrivs vad som händer i en CORS-begäran på HTTP-meddelandenas nivå.

• CORS är inte en säkerhetsfunktion. CORS är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
  • En illasinnad aktör kan till exempel använda XSS (Cross-Site Scripting) mot din webbplats och köra en begäran mellan platser till deras CORS-aktiverade webbplats för att stjäla information.
• Ett API är inte säkrare genom att tillåta CORS.
  • Det är upp till klienten (webbläsaren) att framtvinga CORS. Servern kör begäran och returnerar svaret. Det är klienten som returnerar ett fel och blockerar svaret. Något av följande verktyg visar till exempel serversvaret:
    • Fiddler
    • .NET HttpClient
    • En webbläsare genom att ange URL:en i adressfältet.
• Det är ett sätt för en server att tillåta webbläsare att köra en XHR - eller Fetch API-begäran mellan ursprung som annars skulle vara förbjuden.
  • Webbläsare utan CORS kan inte göra begäranden mellan ursprung. Före CORS användes JSONP för att kringgå denna begränsning. JSONP använder inte XHR, den använder taggen <script> för att ta emot svaret. Skript tillåts att laddas från olika ursprung.

CORS-specifikationen introducerade flera nya HTTP-huvuden som möjliggör begäranden mellan ursprung. Om en webbläsare stöder CORS anger den dessa huvuden automatiskt för begäranden mellan olika ursprung. Anpassad JavaScript-kod krävs inte för att aktivera CORS.

Följande är ett exempel på en begäran om korsande ursprung från testknappen Värden till https://cors1.azurewebsites.net/api/values. Rubrik: Origin

• Tillhandahåller domänen för den webbplats som skickar begäran.
• Det är obligatoriskt och måste skilja sig från värden.

Allmänna rubriker

Request URL: https://cors1.azurewebsites.net/api/values
Request Method: GET
Status Code: 200 OK

Svarshuvuden

Content-Encoding: gzip
Content-Type: text/plain; charset=utf-8
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Transfer-Encoding: chunked
Vary: Accept-Encoding
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Connection: keep-alive
Host: cors1.azurewebsites.net
Origin: https://cors3.azurewebsites.net
Referer: https://cors3.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0 ...

Vid OPTIONS begäranden anger servern SvarshuvudenAccess-Control-Allow-Origin: {allowed origin} i svaret. Till exempel innehåller det distribuerade exemplet Ta bort knappbegäran OPTIONS följande rubriker:

Allmänna rubriker

Request URL: https://cors3.azurewebsites.net/api/TodoItems2/MyDelete2/5
Request Method: OPTIONS
Status Code: 204 No Content

Svarshuvuden

Access-Control-Allow-Headers: Content-Type,x-custom-header
Access-Control-Allow-Methods: PUT,DELETE,GET,OPTIONS
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors3.azurewebsites.net
Vary: Origin
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Headers: content-type
Access-Control-Request-Method: DELETE
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/test?number=2
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

I de föregående svarshuvuden anger servern Access-Control-Allow-Origin headern i svaret. Värdet https://cors1.azurewebsites.net för den här rubriken matchar Origin rubriken i begäran.

Om AllowAnyOrigin anropas, Access-Control-Allow-Origin: *, returneras jokervärdet. AllowAnyOrigin tillåter valfritt ursprung.

Om svaret inte innehåller Access-Control-Allow-Origin huvud misslyckas begäran över ursprung. Mer specifikt tillåter webbläsaren inte begäran. Även om servern returnerar ett lyckat svar gör inte webbläsaren svaret tillgängligt för klientappen.

HTTP-omdirigering till HTTPS, orsakar ERR_INVALID_REDIRECT för CORS-förfrågan vid preflight-begäran.

Begäranden till en slutpunkt med HTTP som omdirigeras till HTTPS med UseHttpsRedirection misslyckas med ERR_INVALID_REDIRECT on the CORS preflight request.

API-projekt kan avvisa HTTP-begäranden i stället för att använda UseHttpsRedirection för att omdirigera begäranden till HTTPS.

Visa OPTIONS-begäranden

Som standard visar chrome- och Edge-webbläsarna inte ALTERNATIV-begäranden på nätverksfliken i F12-verktygen. Så här visar du ALTERNATIV-begäranden i dessa webbläsare:

• chrome://flags/#out-of-blink-cors eller edge://flags/#out-of-blink-cors
• inaktivera flaggan.
• restart.

Firefox visar ALTERNATIV-begäranden som standard.

CORS i IIS

När du distribuerar till IIS måste CORS köras före Windows-autentisering om servern inte är konfigurerad för att tillåta anonym åtkomst. För att stödja det här scenariot måste IIS CORS-modulen installeras och konfigureras för appen.

Testa CORS

Exempelnedladdningen har kod för att testa CORS. Se till hur du laddar ner. Exemplet är ett API-projekt med Razor sidor tillagda:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                        "http://www.contoso.com",
                        "https://cors1.azurewebsites.net",
                        "https://cors3.azurewebsites.net",
                        "https://localhost:44398",
                        "https://localhost:5001")
                            .WithMethods("PUT", "DELETE", "GET");
                });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();
app.MapRazorPages();

app.Run();

Följande ValuesController innehåller slutpunkterna för testning:

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

MyDisplayRouteInfo tillhandahålls av Rick.Docs.Samples.RouteInfo NuGet-paketet och visar väginformation.

Testa föregående exempelkod med någon av följande metoder:

• Kör exemplet med dotnet run och använd standard-URL:en https://localhost:5001.
• Kör exemplet från Visual Studio med porten inställd på 44398 för en URL till https://localhost:44398.

Använda en webbläsare med F12-verktygen:

• Välj knappen Värden och granska rubrikerna på fliken Nätverk .

• Välj knappen PUT-test . Mer information om hur du visar ALTERNATIV-begäran finns i Visa ALTERNATIV-begäranden . PUT-testet skapar två begäranden, en OPTIONS preflight-begäran och PUT-begäran.

• GetValues2 [DisableCors] Välj knappen för att utlösa en misslyckad CORS-begäran. Som nämnts i dokumentet returnerar svaret 200 lyckade resultat, men CORS-begäran görs inte. Välj fliken Konsol för att se CORS-felet. Beroende på webbläsaren visas ett fel som liknar följande:

  Åtkomst till att hämta 'https://cors1.azurewebsites.net/api/values/GetValues2' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Det finns ingen rubrik för "Access-Control-Allow-Origin" på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

CORS-aktiverade slutpunkter kan testas med ett verktyg, till exempel curl eller Fiddler. När du använder ett verktyg måste ursprunget för den begäran som anges av Origin rubriken skilja sig från den värd som tar emot begäran. Om begäran inte är korsdomän baserat på värdet av Origin header:

• CORS Middleware behöver inte bearbeta begäran.
• CORS-huvuden returneras inte i svaret.

Följande kommando använder curl för att utfärda en OPTIONS-begäran med information:

curl -X OPTIONS https://cors3.azurewebsites.net/api/TodoItems2/5 -i

Testa CORS med slutpunktsroutning och [HttpOptions]

Att aktivera CORS per slutpunkt med RequireCors stöder för närvarande inteautomatiska preflight-förfrågningar. Överväg följande kod som använder slutpunktsroutning för att aktivera CORS:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: "MyPolicy",
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                        "http://www.contoso.com",
                        "https://cors1.azurewebsites.net",
                        "https://cors3.azurewebsites.net",
                        "https://localhost:44398",
                        "https://localhost:5001")
                            .WithMethods("PUT", "DELETE", "GET");
                });
});

builder.Services.AddControllers();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();

app.UseCors();

app.UseAuthorization();

app.MapControllers();
app.MapRazorPages();

app.Run();

Följande TodoItems1Controller innehåller slutpunkter för testning:

[Route("api/[controller]")]
[ApiController]
public class TodoItems1Controller : ControllerBase
{
    // PUT: api/TodoItems1/5
    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return Content($"ID = {id}");
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // Delete: api/TodoItems1/5
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // GET: api/TodoItems1
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors]
    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    // Delete: api/TodoItems1/MyDelete2/5
    [EnableCors]
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Testa föregående kod från testsidan (https://cors1.azurewebsites.net/test?number=1) för det distribuerade exemplet.

Knapparna Ta bort [EnableCors] och GET [EnableCors] lyckas, eftersom slutpunkterna har [EnableCors] och svarar på preflight-frågor. De andra slutpunkterna misslyckas. GET-knappen misslyckas eftersom JavaScript skickar:

 headers: {
      "Content-Type": "x-custom-header"
 },

Följande TodoItems2Controller innehåller liknande slutpunkter, men innehåller explicit kod för att svara på OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // [EnableCors] // Not needed as OPTIONS path provided
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    [EnableCors]  // Rquired for this path
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors]  // Rquired for this path
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Föregående kod kan testas genom att distribuera exemplet till Azure. I listrutan Styrenhet, välj Preflight och sedan Ange styrenhet. Alla CORS-anrop till slutpunkterna TodoItems2Controller lyckas.

Ytterligare resurser

• Resursdelning mellan ursprung (CORS)
• Konfigurationsreferens för IIS CORS-modul

Av Rick Anderson och Kirk Larkin

Den här artikeln visar hur du aktiverar CORS i en ASP.NET Core-app.

Webbläsarsäkerhet hindrar en webbsida från att göra begäranden till en annan domän än den som hanterade webbsidan. Den här begränsningen kallas principen för samma ursprung. Principen för samma ursprung förhindrar att en skadlig webbplats läser känsliga data från en annan webbplats. Ibland kanske du vill tillåta att andra webbplatser gör cross-origin-förfrågningar till din app. Mer information finns i artikeln Mozilla CORS.

Resursdelning mellan ursprung (CORS):

• Är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
• Är inte en säkerhetsfunktion, CORS slappnar av säkerheten. Ett API är inte säkrare genom att tillåta CORS. Mer information finns i Så här fungerar CORS.
• Tillåter att en server uttryckligen tillåter vissa begäranden mellan ursprung samtidigt som andra avvisas.
• Är säkrare och mer flexibelt än tidigare tekniker, till exempel JSONP.

Visa eller ladda ned exempelkod (hur du laddar ned)

Samma ursprung

Två URL:er har samma ursprung om de har identiska scheman, värdar och portar (RFC 6454).

Dessa två URL:er har samma ursprung:

• https://example.com/foo.html
• https://example.com/bar.html

Dessa URL:er har olika ursprung än de föregående två URL:erna:

• https://example.net: Olika domän
• https://www.example.com/foo.html: Olika underdomäner
• http://example.com/foo.html: Olika schema
• https://example.com:9000/foo.html: Annorlunda port

Aktivera CORS

Det finns tre sätt att aktivera CORS:

• I mellanprogram med hjälp av en namngiven princip eller standardprincip.
• Använda slutpunktsroutning.
• Med attributet [EnableCors] .

Med attributet [EnableCors] med en namngiven princip får du den bästa kontrollen när det gäller att begränsa slutpunkter som stöder CORS.

Varje metod beskrivs i följande avsnitt.

CORS med namngiven princip och mellanprogram

CORS Middleware hanterar ursprungsöverskridande begäranden. Följande kod tillämpar en CORS-princip på alla appens slutpunkter med angivet ursprung:

public class Startup
{
    readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: MyAllowSpecificOrigins,
                              policy =>
                              {
                                  policy.WithOrigins("http://example.com",
                                                      "http://www.contoso.com");
                              });
        });

        // services.AddResponseCaching();
        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors(MyAllowSpecificOrigins);

        // app.UseResponseCaching();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Föregående kod:

• Anger principnamnet till _myAllowSpecificOrigins. Principnamnet är godtyckligt.
• UseCors Anropar tilläggsmetoden och anger _myAllowSpecificOrigins CORS-principen. UseCors lägger till CORS-mellanprogrammet. Anropet till UseCors måste placeras efter UseRouting, men före UseAuthorization. Mer information finns i Mellanprogramvaruordning.
• Anropar AddCors med ett lambda-uttryck. Lambda tar ett CorsPolicyBuilder objekt. Konfigurationsalternativ, till exempel WithOrigins, beskrivs senare i den här artikeln.
• _myAllowSpecificOrigins Aktiverar CORS-principen för alla kontrollantslutpunkter. Se Slutpunktsroutning för att tillämpa en CORS-princip på specifika slutpunkter.
• När du använder Mellanprogramvara för svarscachelagring anropar du UseCors före UseResponseCaching.

Med slutpunktsroutning måste CORS-mellanprogrammet konfigureras för att köras mellan anropen till UseRouting och UseEndpoints.

Se Testa CORS för instruktioner om att testa kod som liknar föregående kod.

Metodanropet AddCors lägger till CORS-tjänster i appens tjänstcontainer:

public class Startup
{
    readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: MyAllowSpecificOrigins,
                              policy =>
                              {
                                  policy.WithOrigins("http://example.com",
                                                      "http://www.contoso.com");
                              });
        });

        // services.AddResponseCaching();
        services.AddControllers();
    }

Mer information finns i CORS-principalternativ i det här dokumentet.

Metoderna CorsPolicyBuilder kan länkas, enligt följande kod:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy(MyAllowSpecificOrigins,
                          policy =>
                          {
                              policy.WithOrigins("http://example.com",
                                                  "http://www.contoso.com")
                                                  .AllowAnyHeader()
                                                  .AllowAnyMethod();
                          });
    });

    services.AddControllers();
}

Obs! Den angivna URL:en får inte innehålla ett avslutande snedstreck (/). Om URL:en avslutas med /, returneras false och ingen header returneras.

CORS med standardprincip och mellanprogram

Följande markerade kod aktiverar standardprincipen för CORS:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddDefaultPolicy(
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                                        "http://www.contoso.com");
                });
        });

        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Föregående kod tillämpar cors-standardprincipen på alla kontrollantslutpunkter.

Aktivera Cors med slutpunktsroutning

Aktivering av CORS per slutpunkt med hjälp av RequireCorsstöder inte automatiska förhandsbegäranden. Mer information finns i det här GitHub-problemet och Testa CORS med slutpunktsroutning och [HttpOptions].

Med slutpunktsroutning kan CORS aktiveras per slutpunkt med hjälp RequireCors av uppsättningen med tilläggsmetoder:

public class Startup
{
    readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: MyAllowSpecificOrigins,
                              policy =>
                              {
                                  policy.WithOrigins("http://example.com",
                                                      "http://www.contoso.com");
                              });
        });

        services.AddControllers();
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/echo",
                context => context.Response.WriteAsync("echo"))
                .RequireCors(MyAllowSpecificOrigins);

            endpoints.MapControllers()
                     .RequireCors(MyAllowSpecificOrigins);

            endpoints.MapGet("/echo2",
                context => context.Response.WriteAsync("echo2"));

            endpoints.MapRazorPages();
        });
    }
}

I koden ovan:

• app.UseCors aktiverar CORS-mellanprogrammet. Eftersom en standardprincip inte har konfigurerats, aktiverar inte app.UseCors() ensam CORS.
• /echo och kontrollerändpunkterna tillåter begäranden över ursprungsgränser enligt den angivna policyn.
• Slutpunkterna /echo2 och Razor Pages tillåter inte begäranden mellan ursprung eftersom ingen standardprincip har angetts.

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning med RequireCors.

Se Testa CORS med slutpunktsroutning och [HttpOptions] för instruktioner om att testa kod som liknar föregående.

Aktivera CORS med attribut

Att aktivera CORS med attributet [EnableCors] och tillämpa en namngiven princip på endast de slutpunkter som kräver CORS ger den bästa kontrollen.

Attributet [EnableCors] är ett alternativ till att tillämpa CORS globalt. Attributet [EnableCors] aktiverar CORS för valda slutpunkter i stället för alla slutpunkter:

• [EnableCors] anger standardprincipen.
• [EnableCors("{Policy String}")] anger en namngiven princip.

Attributet [EnableCors] kan tillämpas på:

• Razor Sida PageModel
• Controller
• Kontrollantåtgärdsmetod

Olika principer kan tillämpas på kontrollanter, sidmodeller eller åtgärdsmetoder med attributet [EnableCors] . [EnableCors] När attributet tillämpas på en kontrollant, sidmodell eller åtgärdsmetod, och CORS är aktiverat i mellanprogram, tillämpas båda principerna. Vi rekommenderar att du inte kombinerar principer. Använd [EnableCors] attribut eller mellanprogram, inte båda i samma app.

Följande kod tillämpar en annan princip på varje metod:

[Route("api/[controller]")]
[ApiController]
public class WidgetController : ControllerBase
{
    // GET api/values
    [EnableCors("AnotherPolicy")]
    [HttpGet]
    public ActionResult<IEnumerable<string>> Get()
    {
        return new string[] { "green widget", "red widget" };
    }

    // GET api/values/5
    [EnableCors("Policy1")]
    [HttpGet("{id}")]
    public ActionResult<string> Get(int id)
    {
        return id switch
        {
            1 => "green widget",
            2 => "red widget",
            _ => NotFound(),
        };
    }
}

Följande kod skapar två CORS-principer:

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy("Policy1",
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                                        "http://www.contoso.com");
                });

            options.AddPolicy("AnotherPolicy",
                policy =>
                {
                    policy.WithOrigins("http://www.contoso.com")
                                        .AllowAnyHeader()
                                        .AllowAnyMethod();
                });
        });

        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();

        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

För den bästa kontrollen av att begränsa CORS-begäranden:

• Använd [EnableCors("MyPolicy")] med en namngiven princip.
• Definiera inte en standardprincip.
• Använd inte slutpunktsroutning.

Koden i nästa avsnitt uppfyller föregående lista.

Se Testa CORS för instruktioner om att testa kod som liknar föregående kod.

Inaktivera CORS

Attributet [DisableCors] inaktiverar inte CORS som har aktiverats av slutpunktsroutning.

Följande kod definierar CORS-principen "MyPolicy":

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: "MyPolicy",
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                                        "http://www.contoso.com")
                            .WithMethods("PUT", "DELETE", "GET");
                });
        });

        services.AddControllers();
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
            endpoints.MapRazorPages();
        });
    }
}

Följande kod inaktiverar CORS för åtgärden GetValues2 :

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

Föregående kod:

• Aktiverar inte CORS med slutpunktsroutning.
• Definierar inte någon CORS-standardprincip.
• Använder [EnableCors("MyPolicy")] för att aktivera "MyPolicy" CORS-principen för kontrollanten.
• Inaktiverar CORS för GetValues2 metoden.

Mer information om hur du testar koden ovan finns i Testa CORS .

Alternativ för CORS-policy

I det här avsnittet beskrivs de olika alternativ som kan anges i en CORS-princip:

• Ange de tillåtna ursprungen
• Ange tillåtna HTTP-metoder
• Ange de tillåtna begäranderubrikerna
• Ange de synliga svarshuvudena
• Autentiseringsuppgifter i begäranden mellan ursprung
• Ange förtidsförfallotiden

AddPolicy anropas i Startup.ConfigureServices. För vissa alternativ kan det vara bra att läsa avsnittet Hur CORS fungerar först.

Ange de tillåtna ursprungen

AllowAnyOrigin: Tillåter CORS-begäranden från alla ursprung med valfritt schema (http eller https). AllowAnyOrigin är osäker eftersom vilken som helst webbplats kan göra korsursprungsbegäranden till appen.

AllowAnyOrigin påverkar preflightbegäranden och Access-Control-Allow-Origin huvud. Mer information finns i avsnittet Preflight-begäranden .

SetIsOriginAllowedToAllowWildcardSubdomains: Anger IsOriginAllowed att principens egenskap ska vara en funktion som tillåter att ursprung matchar en konfigurerad jokerteckendomän när du utvärderar om ursprunget tillåts.

options.AddPolicy("MyAllowSubdomainPolicy",
    policy =>
    {
        policy.WithOrigins("https://example.com")
            .SetIsOriginAllowedToAllowWildcardSubdomains();
    });

I den föregående kod, SetIsOriginAllowedToAllowWildcardSubdomains anropas med basursprunget "https://example.com". Den här konfigurationen tillåter CORS-begäranden från alla underdomäner i example.com, till exempel https://subdomain.example.com eller https://api.example.com. Jokerteckenmatchningen hanteras av metoden, så ursprunget ska anges utan * jokertecknet.

Ange tillåtna HTTP-metoder

AllowAnyMethod:

• Tillåter alla HTTP-metoder:
• Påverkar preflight-begäranden och Access-Control-Allow-Methods headern. Mer information finns i avsnittet Preflight-begäranden .

Ange de tillåtna begäranderubrikerna

Om du vill tillåta att specifika rubriker skickas i en CORS-begäran, kallad förfrågningsrubriker, anropar du WithHeaders och anger de tillåtna rubrikerna:

options.AddPolicy("MyAllowHeadersPolicy",
    policy =>
    {
        // requires using Microsoft.Net.Http.Headers;
        policy.WithOrigins("http://example.com")
               .WithHeaders(HeaderNames.ContentType, "x-custom-header");
    });

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

options.AddPolicy("MyAllowAllHeadersPolicy",
    policy =>
    {
        policy.WithOrigins("https://*.example.com")
               .AllowAnyHeader();
    });

AllowAnyHeader påverkar preflight-begäranden och 'Access-Control-Request-Headers'-headern. Mer information finns i avsnittet Preflight-begäranden .

En matchning av CORS Middleware-policy mot specifika rubriker som specificeras av WithHeaders är endast möjlig när rubrikerna som skickas i Access-Control-Request-Headers exakt matchar de rubriker som anges i WithHeaders.

Anta till exempel att en app har konfigurerats på följande sätt:

app.UseCors(policy => policy.WithHeaders(HeaderNames.CacheControl));

CORS Middleware nekar en förhandsbegäran med följande begärandehuvud eftersom Content-Language (HeaderNames.ContentLanguage) inte visas i WithHeaders:

Access-Control-Request-Headers: Cache-Control, Content-Language

Appen returnerar ett 200 OK-svar men skickar inte CORS-huvudena tillbaka. Därför försöker inte webbläsaren skicka begäran om korsande ursprung.

Ange de synliga svarshuvudena

Som standardinställning exponerar inte webbläsaren alla svarshuvuden till appen. Mer information finns i Resursdelning mellan ursprung i W3C (terminologi): Enkelt svarshuvud.

Svarshuvudena som är tillgängliga som standard är:

• Cache-Control
• Content-Language
• Content-Type
• Expires
• Last-Modified
• Pragma

CORS-specifikationen kallar dessa rubriker enkla svarsrubriker. Om du vill göra andra rubriker tillgängliga för appen anropar du WithExposedHeaders:

options.AddPolicy("MyExposeResponseHeadersPolicy",
    policy =>
    {
        policy.WithOrigins("https://*.example.com")
               .WithExposedHeaders("x-custom-header");
    });

Autentiseringsuppgifter i begäranden mellan ursprung

Autentiseringsuppgifter kräver särskild hantering i en CORS-begäran. Som standard skickar webbläsaren inte autentiseringsuppgifter med en begäran om korsande ursprung. Autentiseringsuppgifterna omfattar cookies och HTTP-autentiseringsscheman. Om du vill skicka autentiseringsuppgifter med en begäran om korsande ursprung måste klienten ange XMLHttpRequest.withCredentials till true.

Använder XMLHttpRequest direkt:

var xhr = new XMLHttpRequest();
xhr.open('get', 'https://www.example.com/api/test');
xhr.withCredentials = true;

Använda jQuery:

$.ajax({
  type: 'get',
  url: 'https://www.example.com/api/test',
  xhrFields: {
    withCredentials: true
  }
});

Använda Fetch API:

fetch('https://www.example.com/api/test', {
    credentials: 'include'
});

Servern måste tillåta autentiseringsuppgifterna. Om du vill tillåta autentiseringsuppgifter mellan ursprung anropar du AllowCredentials:

options.AddPolicy("MyMyAllowCredentialsPolicy",
    policy =>
    {
        policy.WithOrigins("http://example.com")
               .AllowCredentials();
    });

HTTP-svaret innehåller en Access-Control-Allow-Credentials rubrik som talar om för webbläsaren att servern tillåter autentiseringsuppgifter för en begäran om korsande ursprung.

Om webbläsaren skickar autentiseringsuppgifter men svaret inte innehåller ett giltigt Access-Control-Allow-Credentials huvud exponerar inte webbläsaren svaret för appen och begäran om korsande ursprung misslyckas.

Att tillåta autentiseringsuppgifter mellan ursprung är en säkerhetsrisk. En webbplats på en annan domän kan skicka en inloggad användares autentiseringsuppgifter till appen för användarens räkning utan användarens vetskap.

CORS-specifikationen anger också att att ställa in ursprung till "*" (alla ursprung) är ogiltig om Access-Control-Allow-Credentials headern finns.

Preflight-begäranden

För vissa CORS-begäranden skickar webbläsaren ytterligare en OPTIONS-begäran innan den faktiska begäran görs. Den här begäran kallas för en preflight-begäran. Webbläsaren kan hoppa över preflight-begäran om alla följande villkor är uppfyllda:

• Begärandemetoden är GET, HEAD eller POST.
• Appen anger inte andra begärandehuvuden än Accept, Accept-Language, Content-Language, Content-Typeeller Last-Event-ID.
• Rubriken Content-Type , om den anges, har något av följande värden:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Regeln för begärandehuvuden som angetts för klientbegäran gäller för rubriker som appen anger genom att anropa setRequestHeaderXMLHttpRequest objektet. CORS-specifikationen kallar dessa rubriker förfrågningsrubriker från författare. Regeln gäller inte för rubriker som webbläsaren kan ange, till exempel User-Agent, Hosteller Content-Length.

Följande är ett exempelsvar som liknar preflight-begäran från knappen [Put test] i avsnittet Test CORS i det här dokumentet.

General:
Request URL: https://cors3.azurewebsites.net/api/values/5
Request Method: OPTIONS
Status Code: 204 No Content

Response Headers:
Access-Control-Allow-Methods: PUT,DELETE,GET
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f8...8;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Vary: Origin

Request Headers:
Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Method: PUT
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

Preflight-begäran använder metoden HTTP OPTIONS . Den kan innehålla följande rubriker:

• Access-Control-Request-Method: DEN HTTP-metod som ska användas för den faktiska begäran.
• Access-Control-Request-Headers: En lista över begärandehuvuden som appen anger för den faktiska begäran. Som tidigare nämnts innehåller detta inte rubriker som webbläsaren anger, till exempel User-Agent.
• Access-Control-Allow-Methods

Om preflight-begäran nekas returnerar appen ett 200 OK svar men anger inte CORS-huvudena. Därför försöker inte webbläsaren skicka begäran om korsande ursprung. Ett exempel på en nekad preflight-begäran finns i avsnittet Testa CORS i det här dokumentet.

Med hjälp av F12-verktygen visar konsolappen ett fel som liknar något av följande, beroende på webbläsaren:

• Firefox: Begäran om korsande ursprung blockerad: Samma ursprungsprincip tillåter inte läsning av fjärrresursen på https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5. (Orsak: CORS-begäran lyckades inte). Lära sig mer
• Chromium-baserad: Åtkomst till fetch vid 'https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Svaret på förhandsbegäran passerar inte åtkomstkontrollen: Inget "Access-Control-Allow-Origin"-huvud finns på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

Om du vill tillåta specifika rubriker anropar du WithHeaders:

options.AddPolicy("MyAllowHeadersPolicy",
    policy =>
    {
        // requires using Microsoft.Net.Http.Headers;
        policy.WithOrigins("http://example.com")
               .WithHeaders(HeaderNames.ContentType, "x-custom-header");
    });

För att tillåta alla författarförfrågningsrubriker, anropar du AllowAnyHeader:

options.AddPolicy("MyAllowAllHeadersPolicy",
    policy =>
    {
        policy.WithOrigins("https://*.example.com")
               .AllowAnyHeader();
    });

Webbläsare är inte konsekventa i hur de anger Access-Control-Request-Headers. Om något av följande:

• Rubriker är inställda på något annat än "*"
• AllowAnyHeader heter: Inkludera minst Accept, Content-Typeoch Origin, plus alla anpassade rubriker som du vill stödja.

Automatisk kod för förhandsbegäran

När CORS-principen antingen tillämpas:

• Globalt genom att anropa app.UseCors i Startup.Configure.
• Använda attributet [EnableCors] .

ASP.NET Core svarar på preflight OPTIONS-begäran.

Att aktivera CORS per slutpunkt med hjälp av RequireCors stöder för närvarande inte automatiska preflight-begäranden.

Avsnittet Test CORS i det här dokumentet visar det här beteendet.

[HttpOptions]-attribut för preflight-begäranden

När CORS är aktiverat med rätt princip svarar ASP.NET Core vanligtvis på CORS-förhandsbegäranden automatiskt. I vissa scenarier kanske detta inte är fallet. Du kan till exempel använda CORS med slutpunktsroutning.

Följande kod använder attributet [HttpOptions] för att skapa slutpunkter för OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

Se Testa CORS med slutpunktsroutning och [HttpOptions] för instruktioner om hur du testar föregående kod.

Ange förtidsförfallotiden

Rubriken Access-Control-Max-Age anger hur länge svaret på preflight-begäran kan cachelagras. Om du vill ange den här rubriken anropar du SetPreflightMaxAge:

options.AddPolicy("MySetPreflightExpirationPolicy",
    policy =>
    {
        policy.WithOrigins("http://example.com")
               .SetPreflightMaxAge(TimeSpan.FromSeconds(2520));
    });

Så här fungerar CORS

I det här avsnittet beskrivs vad som händer i en CORS-begäran på HTTP-meddelandenas nivå.

• CORS är inte en säkerhetsfunktion. CORS är en W3C-standard som gör att en server kan lätta på principen för samma ursprung.
  • En illasinnad aktör kan till exempel använda XSS (Cross-Site Scripting) mot din webbplats och köra en begäran mellan platser till deras CORS-aktiverade webbplats för att stjäla information.
• Ett API är inte säkrare genom att tillåta CORS.
  • Det är upp till klienten (webbläsaren) att framtvinga CORS. Servern kör begäran och returnerar svaret. Det är klienten som returnerar ett fel och blockerar svaret. Något av följande verktyg visar till exempel serversvaret:
    • Fiddler
    • .NET HttpClient
    • En webbläsare genom att ange URL:en i adressfältet.
• Det är ett sätt för en server att tillåta webbläsare att köra en XHR - eller Fetch API-begäran mellan ursprung som annars skulle vara förbjuden.
  • Webbläsare utan CORS kan inte göra begäranden mellan ursprung. Före CORS användes JSONP för att kringgå denna begränsning. JSONP använder inte XHR, den använder taggen <script> för att ta emot svaret. Skript tillåts att laddas från olika ursprung.

CORS-specifikationen introducerade flera nya HTTP-huvuden som möjliggör begäranden mellan ursprung. Om en webbläsare stöder CORS anger den dessa huvuden automatiskt för begäranden mellan olika ursprung. Anpassad JavaScript-kod krävs inte för att aktivera CORS.

Följande är ett exempel på en begäran om korsande ursprung från testknappen Värden till https://cors1.azurewebsites.net/api/values. Rubrik: Origin

• Tillhandahåller domänen för den webbplats som skickar begäran.
• Det är obligatoriskt och måste skilja sig från värden.

Allmänna rubriker

Request URL: https://cors1.azurewebsites.net/api/values
Request Method: GET
Status Code: 200 OK

Svarshuvuden

Content-Encoding: gzip
Content-Type: text/plain; charset=utf-8
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors1.azurewebsites.net
Transfer-Encoding: chunked
Vary: Accept-Encoding
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Connection: keep-alive
Host: cors1.azurewebsites.net
Origin: https://cors3.azurewebsites.net
Referer: https://cors3.azurewebsites.net/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0 ...

Vid OPTIONS begäranden anger servern SvarshuvudenAccess-Control-Allow-Origin: {allowed origin} i svaret. Till exempel innehåller det distribuerade exemplet Ta bort knappbegäran OPTIONS följande rubriker:

Allmänna rubriker

Request URL: https://cors3.azurewebsites.net/api/TodoItems2/MyDelete2/5
Request Method: OPTIONS
Status Code: 204 No Content

Svarshuvuden

Access-Control-Allow-Headers: Content-Type,x-custom-header
Access-Control-Allow-Methods: PUT,DELETE,GET,OPTIONS
Access-Control-Allow-Origin: https://cors1.azurewebsites.net
Server: Microsoft-IIS/10.0
Set-Cookie: ARRAffinity=8f...;Path=/;HttpOnly;Domain=cors3.azurewebsites.net
Vary: Origin
X-Powered-By: ASP.NET

Begärandehuvuden

Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Access-Control-Request-Headers: content-type
Access-Control-Request-Method: DELETE
Connection: keep-alive
Host: cors3.azurewebsites.net
Origin: https://cors1.azurewebsites.net
Referer: https://cors1.azurewebsites.net/test?number=2
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: cross-site
User-Agent: Mozilla/5.0

I de föregående svarshuvuden anger servern Access-Control-Allow-Origin headern i svaret. Värdet https://cors1.azurewebsites.net för den här rubriken matchar Origin rubriken i begäran.

Om AllowAnyOrigin anropas, Access-Control-Allow-Origin: *, returneras jokervärdet. AllowAnyOrigin tillåter valfritt ursprung.

Om svaret inte innehåller Access-Control-Allow-Origin huvud misslyckas begäran över ursprung. Mer specifikt tillåter webbläsaren inte begäran. Även om servern returnerar ett lyckat svar gör inte webbläsaren svaret tillgängligt för klientappen.

Visa OPTIONS-begäranden

Som standard visar chrome- och Edge-webbläsarna inte ALTERNATIV-begäranden på nätverksfliken i F12-verktygen. Så här visar du ALTERNATIV-begäranden i dessa webbläsare:

• chrome://flags/#out-of-blink-cors eller edge://flags/#out-of-blink-cors
• inaktivera flaggan.
• restart.

Firefox visar ALTERNATIV-begäranden som standard.

CORS i IIS

När du distribuerar till IIS måste CORS köras före Windows-autentisering om servern inte är konfigurerad för att tillåta anonym åtkomst. För att stödja det här scenariot måste IIS CORS-modulen installeras och konfigureras för appen.

Testa CORS

Exempelnedladdningen har kod för att testa CORS. Se till hur du laddar ner. Exemplet är ett API-projekt med Razor sidor tillagda:

public class StartupTest2
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: "MyPolicy",
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                        "http://www.contoso.com",
                        "https://cors1.azurewebsites.net",
                        "https://cors3.azurewebsites.net",
                        "https://localhost:44398",
                        "https://localhost:5001")
                            .WithMethods("PUT", "DELETE", "GET");
                });
        });

        services.AddControllers();
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
            endpoints.MapRazorPages();
        });
    }
}

Följande ValuesController innehåller slutpunkterna för testning:

[EnableCors("MyPolicy")]
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
    // GET api/values
    [HttpGet]
    public IActionResult Get() =>
        ControllerContext.MyDisplayRouteInfo();

    // GET api/values/5
    [HttpGet("{id}")]
    public IActionResult Get(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // PUT api/values/5
    [HttpPut("{id}")]
    public IActionResult Put(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);


    // GET: api/values/GetValues2
    [DisableCors]
    [HttpGet("{action}")]
    public IActionResult GetValues2() =>
        ControllerContext.MyDisplayRouteInfo();

}

MyDisplayRouteInfo tillhandahålls av Rick.Docs.Samples.RouteInfo NuGet-paketet och visar väginformation.

Testa föregående exempelkod med någon av följande metoder:

• Kör exemplet med dotnet run och använd standard-URL:en https://localhost:5001.
• Kör exemplet från Visual Studio med porten inställd på 44398 för en URL till https://localhost:44398.

Använda en webbläsare med F12-verktygen:

• Välj knappen Värden och granska rubrikerna på fliken Nätverk .

• Välj knappen PUT-test . Mer information om hur du visar ALTERNATIV-begäran finns i Visa ALTERNATIV-begäranden . PUT-testet skapar två begäranden, en OPTIONS preflight-begäran och PUT-begäran.

• GetValues2 [DisableCors] Välj knappen för att utlösa en misslyckad CORS-begäran. Som nämnts i dokumentet returnerar svaret 200 lyckade resultat, men CORS-begäran görs inte. Välj fliken Konsol för att se CORS-felet. Beroende på webbläsaren visas ett fel som liknar följande:

  Åtkomst till att hämta 'https://cors1.azurewebsites.net/api/values/GetValues2' från ursprung 'https://cors3.azurewebsites.net' har blockerats av CORS-principen: Det finns ingen rubrik för "Access-Control-Allow-Origin" på den begärda resursen. Om ett ogenomskinligt svar uppfyller dina behov, ställ in begärans läge på "no-cors" för att hämta resursen med CORS inaktiverat.

CORS-aktiverade slutpunkter kan testas med ett verktyg, till exempel curl eller Fiddler. När du använder ett verktyg måste ursprunget för den begäran som anges av Origin rubriken skilja sig från den värd som tar emot begäran. Om begäran inte är korsdomän baserat på värdet av Origin header:

• CORS Middleware behöver inte bearbeta begäran.
• CORS-huvuden returneras inte i svaret.

Följande kommando använder curl för att utfärda en OPTIONS-begäran med information:

curl -X OPTIONS https://cors3.azurewebsites.net/api/TodoItems2/5 -i

Testa CORS med slutpunktsroutning och [HttpOptions]

Att aktivera CORS per slutpunkt med RequireCors stöder för närvarande inteautomatiska preflight-förfrågningar. Överväg följande kod som använder slutpunktsroutning för att aktivera CORS:

public class StartupEndPointBugTest
{
    readonly string MyPolicy = "_myPolicy";

    // .WithHeaders(HeaderNames.ContentType, "x-custom-header")
    // forces browsers to require a preflight request with GET

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy(name: MyPolicy,
                policy =>
                {
                    policy.WithOrigins("http://example.com",
                                        "http://www.contoso.com",
                                        "https://cors1.azurewebsites.net",
                                        "https://cors3.azurewebsites.net",
                                        "https://localhost:44398",
                                        "https://localhost:5001")
                           .WithHeaders(HeaderNames.ContentType, "x-custom-header")
                           .WithMethods("PUT", "DELETE", "GET", "OPTIONS");
                });
        });

        services.AddControllers();
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseCors();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers().RequireCors(MyPolicy);
            endpoints.MapRazorPages();
        });
    }
}

Följande TodoItems1Controller innehåller slutpunkter för testning:

[Route("api/[controller]")]
[ApiController]
public class TodoItems1Controller : ControllerBase
{
    // PUT: api/TodoItems1/5
    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return Content($"ID = {id}");
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // Delete: api/TodoItems1/5
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    // GET: api/TodoItems1
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors]
    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    // Delete: api/TodoItems1/MyDelete2/5
    [EnableCors]
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Testa föregående kod från testsidan (https://cors1.azurewebsites.net/test?number=1) för det distribuerade exemplet.

Knapparna Ta bort [EnableCors] och GET [EnableCors] lyckas, eftersom slutpunkterna har [EnableCors] och svarar på preflight-frågor. De andra slutpunkterna misslyckas. GET-knappen misslyckas eftersom JavaScript skickar:

 headers: {
      "Content-Type": "x-custom-header"
 },

Följande TodoItems2Controller innehåller liknande slutpunkter, men innehåller explicit kod för att svara på OPTIONS-begäranden:

[Route("api/[controller]")]
[ApiController]
public class TodoItems2Controller : ControllerBase
{
    // OPTIONS: api/TodoItems2/5
    [HttpOptions("{id}")]
    public IActionResult PreflightRoute(int id)
    {
        return NoContent();
    }

    // OPTIONS: api/TodoItems2 
    [HttpOptions]
    public IActionResult PreflightRoute()
    {
        return NoContent();
    }

    [HttpPut("{id}")]
    public IActionResult PutTodoItem(int id)
    {
        if (id < 1)
        {
            return BadRequest();
        }

        return ControllerContext.MyDisplayRouteInfo(id);
    }

    // [EnableCors] // Not needed as OPTIONS path provided
    [HttpDelete("{id}")]
    public IActionResult MyDelete(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);

    [EnableCors]  // Rquired for this path
    [HttpGet]
    public IActionResult GetTodoItems() =>
        ControllerContext.MyDisplayRouteInfo();

    [HttpGet("{action}")]
    public IActionResult GetTodoItems2() =>
        ControllerContext.MyDisplayRouteInfo();

    [EnableCors]  // Rquired for this path
    [HttpDelete("{action}/{id}")]
    public IActionResult MyDelete2(int id) =>
        ControllerContext.MyDisplayRouteInfo(id);
}

Föregående kod kan testas genom att distribuera exemplet till Azure. I listrutan Styrenhet, välj Preflight och sedan Ange styrenhet. Alla CORS-anrop till slutpunkterna TodoItems2Controller lyckas.

Ytterligare resurser

• Resursdelning mellan ursprung (CORS)
• Konfigurationsreferens för IIS CORS-modul