Forrásközi kérelmek (CORS) engedélyezése a ASP.NET Core-ban

Rick Anderson és Kirk Larkin

A cikk bemutatja, hogyan engedélyezik a Cross-Origin Resource Sharing (CORS) használatát egy ASP.NET Core alkalmazásban.

A böngésző biztonsága megakadályozza, hogy egy weblap kéréseket küldjön a weblapot kézbesítő tartománytól eltérő tartományba. Ezt a korlátozást azonos eredetű szabálynaknevezzük. Az azonos eredetű házirend megakadályozza, hogy egy rosszindulatú webhely bizalmas adatokat olvasson egy másik webhelyről. Előfordulhat, hogy engedélyezni szeretné, hogy más webhelyek kereszt-domain kérelmeket indíthassanak az alkalmazásához. További információ: Mozilla CORS-cikk.

Forrásközi erőforrásmegosztás (CORS):

• Egy W3C szabvány, amely lehetővé teszi, hogy a kiszolgáló lazítja az azonos eredetű tartalomra alkalmazott szabályt.
• Nem jelent biztonsági funkciót, a CORS csökkenti a biztonságot. Az API-k nem biztonságosabbak a CORS engedélyezésével. További információ: A CORS működése.
• Lehetővé teszi, hogy a kiszolgáló explicit módon engedélyezze a forrásközi kéréseket, miközben elutasít másokat.
• Biztonságosabb és rugalmasabb, mint a korábbi technikák, például a JSONP.

Mintakód megtekintése vagy letöltése (hogyan töltsd le)

Ugyanaz a forrás

Két URL azonos eredetű, ha azonos sémákkal, gazdagépekkel és portokkal rendelkeznek (RFC 6454).

Ennek a két URL-címnek ugyanaz a eredete:

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

Ezek az URL-címek eltérő eredetűek, mint az előző két URL-cím:

• https://example.net: Eltérő tartomány
• https://contoso.example.com/foo.html: Eltérő altartomány
• http://example.com/foo.html: Eltérő séma
• https://example.com:9000/foo.html: Eltérő port

CORS engedélyezése

A CORS engedélyezésének három módja van:

• A köztes szoftverben kétféle politika használható: nevesített politika vagy alapértelmezett politika.
• Végpont-útválasztás használata.
• Az [EnableCors] attribútummal.

Az [EnableCors] attribútum nevesített szabályzattal való használata biztosítja a legjobb vezérlést a CORS-t támogató végpontok korlátozásához.

Warning

UseCors a megfelelő sorrendben kell meghívni. További információ: Middleware order. Például a UseCors-t meg kell hívni, mielőtt a UseResponseCaching használatára kerül sor, illetve mielőtt a UseResponseCaching-t használják.

Az egyes megközelítéseket a következő szakaszok ismertetik.

CORS nevesített szabályzattal és köztes szoftverrel

A CORS Middleware kezeli a forrásközi kéréseket. Az alábbi kód egy CORS-szabályzatot alkalmaz az alkalmazás összes végpontjára a megadott forrásokkal:

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

Az előző kód:

• A házirend nevét a következőre _myAllowSpecificOriginsállítja be: . A szabályzat neve tetszőleges.
• Meghívja a UseCors bővítménymetódust, és megadja a _myAllowSpecificOrigins CORS-szabályzatot. UseCors hozzáadja a CORS köztes szoftverét. A hívást a UseCors után kell elhelyezni, de a UseRouting előtt. További információ: Middleware order.
• AddCors rendelkező hívások. A lambda elvisz egy objektumot CorsPolicyBuilder . A konfigurációs beállításokat, például WithOriginsa jelen cikk későbbi részében ismertetjük.
• Engedélyezi a _myAllowSpecificOrigins CORS-szabályzatot az összes vezérlővégponthoz. A cors-szabályzat adott végpontokra való alkalmazásához tekintse meg a végpont-útválasztást .
• Amikor a Response Caching Middleware-t használja, hívja megUseCorsUseResponseCaching előtt.

Végponti útválasztásnál a CORS köztes szoftvert úgy kell konfigurálni, hogy a `` és `UseRouting` hívások között hajtson végre.

A AddCors metódushívás CORS-szolgáltatásokat ad hozzá az alkalmazás szolgáltatástárolóhoz:

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

További információ: CORS-szabályzat beállításai ebben a dokumentumban.

A CorsPolicyBuilder metódusok láncolhatók, ahogy az a következő kódban is látható:

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

Megjegyzés: A megadott URL-cím nem tartalmazhat záró perjelet (/). Ha az URL-cím ezzel /végződik, az összehasonlítás eredményül ad false vissza, és nem ad vissza fejlécet.

UseCors és UseStaticFiles sorrendje

Általában UseStaticFiles van meghívva UseCors előtt. A JavaScriptet használó alkalmazásoknak először fel kell hívniuk a UseCors-t, mielőtt a UseStaticFiles-et helyek közötti statikus fájlok lekéréséhez.

CORS alapértelmezett szabályzattal és köztes szoftverrel

Az alábbi kiemelt kód engedélyezi az alapértelmezett CORS-szabályzatot:

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

Az előző kód az alapértelmezett CORS-szabályzatot alkalmazza az összes vezérlővégpontra.

Cors engedélyezése végponti útválasztással

A végponti útválasztással a CORS végpontonként engedélyezhető a RequireCors bővítménymetelyek halmazával:

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

Az előző kódban:

• app.UseCors lehetővé teszi a CORS köztes szoftverét. Mivel az alapértelmezett szabályzat nincs konfigurálva, app.UseCors() önmagában nem engedélyezi a CORS-t.
• A /echo vezérlővégpontok engedélyezik a forrásközi kéréseket a megadott szabályzat használatával.
• A /echo2 Lapok és Razor a Lapok végpontok nem engedélyezik a forrásközi kéréseket, mert nincs megadva alapértelmezett szabályzat.

A [DisableCors] attribútum nem tiltja le a CORS-t, amelyet a végponti útválasztás engedélyezett a következővel RequireCors: .

Az előzőhöz hasonló tesztelési kódra vonatkozó utasításokért tekintse meg a CORS tesztelését az [EnableCors] attribútummal és a RequireCors metódussal .

CORS engedélyezése attribútumokkal

Ha engedélyezi a CORS-t az [EnableCors] attribútummal, és egy elnevezett szabályzatot alkalmaz csak azokra a végpontokra, amelyekhez CORS szükséges, a legjobb vezérlést biztosítja.

Az [EnableCors] attribútum alternatívát kínál a CORS globális alkalmazásához. Az [EnableCors] attribútum az összes végpont helyett engedélyezi a CORS-t a kijelölt végpontok számára:

• [EnableCors] az alapértelmezett szabályzatot adja meg.
• [EnableCors("{Policy String}")] egy elnevezett szabályzatot határoz meg.

A [EnableCors] attribútum a következőre alkalmazható:

• Razor Oldal PageModel
• Controller
• Vezérlőműveleti módszer

Az attribútummal [EnableCors] rendelkező vezérlőkre, oldalmodellekre vagy műveleti módszerekre különböző szabályzatok alkalmazhatók. Ha az [EnableCors] attribútum egy vezérlőre, oldalmodellre vagy műveleti módszerre van alkalmazva, és a CORS engedélyezve van a köztes szoftverben, a rendszer mindkét szabályzatot alkalmazza. Azt javasoljuk, hogy ne kombinálják a szabályzatokat. Használja a [EnableCors] attribútum vagy köztes szoftver, nem ugyanabban az alkalmazásban.

Az alábbi kód egy másik szabályzatot alkalmaz az egyes metódusokra:

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

A következő kód két CORS-szabályzatot hoz létre:

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

A CORS-kérelmek korlátozásának legkiválóbb szabályozásához:

• Használd a [EnableCors("MyPolicy")] a névvel ellátott szabályzattal.
• Ne definiáljon alapértelmezett szabályzatot.
• Ne használjon végpont-útválasztást.

A következő szakaszban szereplő kód megfelel az előző listának.

CORS letiltása

A [DisableCors] attribútum nem tiltja le a végpont-útválasztás által engedélyezett CORS-t.

A CORS-szabályzatot "MyPolicy"a következő kód határozza meg:

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

A következő kód letiltja a CORS-t a GetValues2 művelethez:

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

}

Az előző kód:

• Nem engedélyezi a CORS-t végponti útválasztással.
• Nem definiál alapértelmezett CORS-szabályzatot.
• A [EnableCors("MyPolicy")] használatával engedélyezi a "MyPolicy" CORS-szabályzatot a vezérlő számára.
• Letiltja a CORS-t a GetValues2 metódushoz.

Az előző kód tesztelésére vonatkozó utasításokat a CORS tesztelése című témakörben találja.

CORS-szabályzat beállításai

Ez a szakasz a CORS-házirendekben beállítható különböző beállításokat ismerteti:

• Az engedélyezett forrás beállítása
• Az engedélyezett HTTP-metódusok beállítása
• Az engedélyezett kérelemfejlécek beállítása
• A közzétett válaszfejlécek beállítása
• Hitelesítő adatok a forrásközi kérelmekben
• Az előzetes lejárati idő beállítása

AddPolicy be van hívva Program.cs. Néhány lehetőség esetén hasznos lehet először elolvasni a CORS működését ismertető szakaszt.

Az engedélyezett forrás beállítása

AllowAnyOrigin: Engedélyezi a CORS-kérelmeket minden forrásból bármilyen sémával (http vagy https). AllowAnyOrigin nem biztonságos, mert bármely webhely keresztirányú kéréseket tud küldeni az alkalmazásnak.

Note

A AllowAnyOrigin és AllowCredentials megadása nem biztonságos konfiguráció, és helyek közötti kérések hamisításához vezethet. A CORS szolgáltatás érvénytelen CORS-választ ad vissza, ha egy alkalmazás mindkét módszerrel van konfigurálva.

AllowAnyOrigin befolyásolja az elővizsgálati kérelmeket és a Access-Control-Allow-Origin fejléceket. További információ: Előzetes kérések szakasz.

SetIsOriginAllowedToAllowWildcardSubdomains: A házirend tulajdonságát olyan függvényként állítja be IsOriginAllowed , amely lehetővé teszi, hogy a forrás egyezzen a konfigurált helyettesítő karakterek tartományával, amikor kiértékeli, hogy engedélyezett-e a forrás.

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

Az előző kódban a SetIsOriginAllowedToAllowWildcardSubdomains a "https://example.com" alapforrással van meghívva. Ez a konfiguráció lehetővé teszi a CORS-kérelmeket bármely altartományból example.com, például https://subdomain.example.com vagy https://api.example.com. A helyettesítő karakterek egyeztetését a metódus kezeli, ezért az eredetit * helyettesítő karakter nélkül kell megadni.

Az engedélyezett HTTP-metódusok beállítása

AllowAnyMethod:

• Bármely HTTP-metódust engedélyez:
• Hatással van az elővizsgálati kérelmekre és a Access-Control-Allow-Methods fejlécre. További információ: Előzetes kérések szakasz.

Az engedélyezett kérelemfejlécek beállítása

Ha engedélyezni szeretné, hogy bizonyos fejlécek egy CORS-kérelemben, úgynevezett szerzői kérelemfejlécekben legyenek elküldve, hívja meg WithHeaders és adja meg az engedélyezett fejléceket:

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

Az összes szerzői kérelem fejlécének engedélyezéséhez hívja meg a következőt 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 hatással van az előzetes kérelmekre és az Access-Control-Request-Headers fejlécre. További információ: Előzetes kérések szakasz.

A CORS Middleware-szabályzat csak akkor egyezik meg a megadott WithHeaders fejlécekkel, ha az elküldött Access-Control-Request-Headers fejlécek pontosan megegyeznek a megadott WithHeadersfejlécekkel.

Fontolja meg például az alábbi módon konfigurált alkalmazást:

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

A CORS Middleware elutasít egy elővizsgálati kérelmet a következő kérelemfejléccel, mert Content-Language a (HeaderNames.ContentLanguage) nem szerepel a WithHeaderslistán:

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

Az alkalmazás 200 OK választ ad vissza, de nem küldi vissza a CORS-fejléceket. Ezért a böngésző nem próbálja meg a forrásközi kérést.

A közzétett válaszfejlécek beállítása

Alapértelmezés szerint a böngésző nem teszi elérhetővé az összes válaszfejlécet az alkalmazás számára. További információt a W3C forrásközi erőforrás-megosztás (terminológia): Egyszerű válaszfejléc című témakörben talál.

Az alapértelmezés szerint elérhető válaszfejlécek a következők:

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

A CORS-specifikáció ezeket a fejléceket egyszerű válaszfejléceknek nevezi. Ha más fejléceket szeretne elérhetővé tenni az alkalmazás számára, hívja meg a következőt 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();

Hitelesítő adatok a forrásközi kérelmekben

A hitelesítő adatok speciális kezelést igényelnek a CORS-kérelmekben. Alapértelmezés szerint a böngésző nem küld hitelesítő adatokat keresztirányú kéréssel. A hitelesítő adatok közé tartoznak a cookie-k és a HTTP-hitelesítési sémák. Ha a hitelesítő adatokat forrásközi kéréssel szeretné elküldeni, az ügyfélnek a következőre kell állítania XMLHttpRequest.withCredentials : true.

XMLHttpRequest közvetlen használata:

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

A jQuery használata:

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

A Fetch API használata:

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

A kiszolgálónak engedélyeznie kell a hitelesítő adatokat. A forrásközi hitelesítő adatok engedélyezéséhez hívja meg a következőt 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();

A HTTP-válasz tartalmaz egy fejlécet Access-Control-Allow-Credentials , amely tájékoztatja a böngészőt, hogy a kiszolgáló engedélyezi a hitelesítő adatokat a forrásközi kérésekhez.

Ha a böngésző hitelesítő adatokat küld, de a válasz nem tartalmaz érvényes Access-Control-Allow-Credentials fejlécet, a böngésző nem teszi elérhetővé a választ az alkalmazásnak, és a forrásközi kérés meghiúsul.

A forrásközi hitelesítő adatok engedélyezése biztonsági kockázatot jelent. Egy másik tartomány webhelye a felhasználó tudta nélkül küldheti el a bejelentkezett felhasználó hitelesítő adatait az alkalmazásnak a felhasználó nevében.

A CORS-specifikáció azt is kimondja, hogy az eredetek "*" (minden eredet) beállítása érvénytelen, ha a Access-Control-Allow-Credentials fejléc jelen van.

Előzetes kérések

Egyes CORS-kérések esetén a böngésző további BEÁLLÍTÁSOK kérést küld a tényleges kérés végrehajtása előtt. Ezt a kérést előzetes kérésnek nevezzük. A böngésző kihagyhatja az elővizsgálati kérést, ha az alábbi feltételek teljesülnek :

• A kérelem metódusa a GET, a HEAD vagy a POST.
• Az alkalmazás nem állít be más kérésfejléceket, mint Accept, Accept-Language, Content-Language, Content-Type vagy Last-Event-ID.
• Ha Content-Type be van állítva a fejléc, az alábbi értékek egyikével rendelkezik:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Az ügyfélkérés fejléceire vonatkozó szabály azokban az esetekben alkalmazandó, amikor az alkalmazás az setRequestHeader hívással állít be fejléceket az XMLHttpRequest objektumon. A CORS-specifikáció ezeket a fejléceket felhasználói kérés fejléceként nevezi. A szabály nem vonatkozik a böngésző által beállítható fejlécekre, például User-Agent: , Hostvagy Content-Length.

Note

Ez a cikk a mintakód két Azure-webhelyen való üzembe helyezésével létrehozott URL-címeket tartalmaz, https://cors3.azurewebsites.net valamint https://cors.azurewebsites.net.

Az alábbi példa a [Teszt gomb] által küldött elővizsgálati kéréshez hasonló válasz a dokumentum CORS teszt szakaszában.

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

Az előzetes kérés a HTTP OPTIONS metódust használja. A következő fejléceket tartalmazhatja:

• Access-Control-Request-Metódus: A tényleges kéréshez használt HTTP-metódus.
• Access-Control-Request-Headers: Az alkalmazás által a tényleges kérelemre megadott kérelemfejlécek listája. Ahogy korábban említettem, ez nem tartalmazza a böngésző által megadott fejléceket, például User-Agent.

Ha a rendszer megtagadja az előzetes kérést, az alkalmazás egy 200 OK választ ad, de nem állítja be a CORS-fejléceket. Ezért a böngésző nem próbálja meg a forrásközi kérést. A megtagadott elővizsgálati kérésre példaként tekintse meg a dokumentum CORS-teszt szakaszát.

Az F12-eszközökkel a konzolalkalmazás a böngészőtől függően az alábbihoz hasonló hibát jelenít meg:

• Firefox: A forrásközi kérés blokkolva van: Ugyanaz az eredetszabályzat nem engedélyezi a távoli erőforrás beolvasását a következő helyen https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5: . (Ok: A CORS-kérés nem sikerült). Tudj meg többet
• Chromium-alapú: A „https://cors1.azurewebsites.net/api/TodoItems1/MyDelete2/5” forrásból a „https://cors3.azurewebsites.net” originre történő lekéréshez való hozzáférést a CORS-szabályzat blokkolta: Az előzetes lekérési kérésre adott válasz nem felel meg a hozzáférés-vezérlés ellenőrzésének: A kért erőforráson nincs „Access-Control-Allow-Origin” fejléc jelen. Ha egy átlátszatlan válasz megfelel az igényeinek, állítsa a kérés módját "no-cors" értékre, hogy lekérje az erőforrást, ha a CORS le van tiltva.

Adott fejlécek engedélyezéséhez hívja meg a következőt 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();

Az összes szerzői kérelem fejlécének engedélyezéséhez hívja meg a következőt 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();

A böngészők nem konzisztensek a beállításuk Access-Control-Request-Headersmódjában. Ha a következők valamelyike van:

• Az élőfejek beállítása bármi másra, mint "*"
• AllowAnyHeader neve: Adja meg legalább Accept, Content-Type, Origin, valamint minden olyan egyéni fejlécet, amelyet támogatni szeretne.

Automatikus előzetes kérelemkód

A CORS-szabályzat alkalmazásakor:

• Globálisan behívással app.UseCorsProgram.cs.
• [EnableCors] Az attribútum használata.

ASP.NET Core válaszol az elővizsgálati BEÁLLÍTÁSOK kérésre.

A dokumentum CORS tesztelési szakasza ezt a viselkedést mutatja be.

[HttpOptions] attribútum az előzetes kérésekhez

Ha a CORS engedélyezve van a megfelelő szabályzattal, ASP.NET Core általában automatikusan válaszol a CORS elővizsgálati kéréseire.

A következő kód a [HttpOptions] attribútummal hoz létre végpontokat az OPTIONS-kérelmekhez:

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

Az előző kód tesztelésére vonatkozó utasításokért lásd: CORS tesztelése [EnableCors] attribútummal és RequireCors metódussal .

Az előzetes lejárati idő beállítása

A Access-Control-Max-Age fejléc azt határozza meg, hogy mennyi ideig lehet gyorsítótárazni az elővizsgálati kérelemre adott választ. A fejléc beállításához hívja meg a következőt 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();

CORS engedélyezése végponton

A CORS működése

Ez a szakasz azt ismerteti, hogy mi történik a CORS-kérelmekben a HTTP-üzenetek szintjén.

• A CORS nem biztonsági funkció. A CORS egy W3C szabvány, amely lehetővé teszi a kiszolgáló számára, hogy lazítson az azonos eredetű házirenden.
  • Egy rosszindulatú szereplő például használhatja a cross-site scriptinget (XSS) a webhelyen, és keresztoldali kérést hajthat végre a CORS-kompatibilis webhelyre az információk ellopásához.
• Az API-k nem biztonságosabbak a CORS engedélyezésével.
  • A CORS kényszerítése az ügyfélen (böngészőn) múlik. A kiszolgáló végrehajtja a kérést, és visszaadja a választ, az ügyfél ad vissza egy hibát, és blokkolja a választ. Például az alábbi eszközök bármelyike megjeleníti a kiszolgáló válaszát:
    • Fiddler
    • .NET HttpClient
    • Írja be az URL-címet a címsorba a webböngészőben.
• Ez egy módja annak, hogy a kiszolgáló lehetővé tegye a böngészők számára egy kereszt-eredetű XHR - vagy Fetch API-kérés végrehajtását, amely egyébként tiltott lenne.
  • A CORS-t nem igénylő böngészők nem hajthatnak végre forrásközi kéréseket. A CORS előtt a JSONP-t használták a korlátozás megkerülésére. A JSONP nem XHR-t használ, hanem a <script> címkét használja a válasz fogadásához. A szkriptek több forrásból tölthetők be.

A CORS-specifikáció számos új HTTP-fejlécet vezetett be, amelyek lehetővé teszik a forrásközi kéréseket. Ha egy böngésző támogatja a CORS-t, automatikusan beállítja ezeket a fejléceket a forrásközi kérelmekhez. A CORS engedélyezéséhez nincs szükség egyéni JavaScript-kódra.

Az alábbi példa egy keresztirányú kérésre az Értékek teszt gombtól a következőig https://cors1.azurewebsites.net/api/values: A Origin fejléc:

• Megadja a kérést küldő webhely tartományát.
• Kötelező, és másnak kell lennie, mint a gazdagépnek.

Általános fejlécek

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

Válaszfejlécek

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

Kérelemfejlécek

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

A kérelmekben OPTIONS a kiszolgáló beállítja a Válasz fejlécekAccess-Control-Allow-Origin: {allowed origin} fejlécét a válaszban. A mintakódban például a Delete [EnableCors] gombkérés OPTIONS a következő fejléceket tartalmazza:

Általános fejlécek

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

Válaszfejlécek

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

Kérelemfejlécek

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

Az előző válaszfejlécekben a kiszolgáló beállítja az Access-Control-Allow-Origin fejlécet a válaszban. A https://cors1.azurewebsites.net fejléc értéke megegyezik a Origin kérelem fejlécével.

Ha meghívják a AllowAnyOrigin, akkor a Access-Control-Allow-Origin: *, a helyettesítő karakter értéke kerül visszaadásra. AllowAnyOrigin bármilyen forrást engedélyez.

Ha a válasz nem tartalmazza a Access-Control-Allow-Origin fejlécet, a forrásközi kérés meghiúsul. Pontosabban a böngésző letiltja a kérést. Még ha a kiszolgáló sikeres választ is ad vissza, a böngésző nem teszi elérhetővé a választ az ügyfélalkalmazás számára.

A HTTP-ről HTTPS-re történő átirányítás ERR_INVALID_REDIRECT hibát okoz a CORS-elővizsgálati kérelemben.

Http-t használó végpontra irányuló kérések, amelyeket a rendszer a KÖVETKEZŐ hibával UseHttpsRedirectionátirányít a HTTPS-hezERR_INVALID_REDIRECT on the CORS preflight request.

Az API-projektek elutasíthatják a HTTP-kéréseket, ahelyett, hogy UseHttpsRedirection segítségével irányítanák át a kéréseket HTTPS-re.

CORS az IIS-ben

Az IIS-ben való üzembe helyezéskor a CORS-nak a Windows-hitelesítés előtt kell futnia, ha a kiszolgáló nincs a névtelen hozzáférés engedélyezésére konfigurálva. A forgatókönyv támogatásához telepíteni és konfigurálni kell az IIS CORS modult az alkalmazáshoz.

CORS tesztelése

A mintaletöltés kóddal rendelkezik a CORS teszteléséhez. Tekintse meg , hogyan töltheti le. A minta egy API-projekt, amelyhez Razor Pages hozzáadva:

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

Warning

WithOrigins("https://localhost:<port>"); csak a letöltési mintakódhoz hasonló mintaalkalmazás tesztelésére használható.

Note

Ha a Visual Studio-t vagy a launchSettings.json használja a VS Code C#-hibakeresési beállításainak konfigurálásával, és az IIS Express-t használja helyi hibakereséshez, győződjön meg arról, hogy az IIS Express-t konfigurálta a(z) "anonymousAuthentication": true számára. Ha "anonymousAuthentication" igen false, a ASP.NET Core webes környezet gazdagépe nem lát elővizsgálati kéréseket. Különösen, ha NTLM-hitelesítést ("windowsAuthentication": true) használ, az NTLM kihívás-válasz első lépése egy 401-es feladat elküldése a webböngészőnek, ami megnehezítheti az elővizsgálati útvonal helyes konfigurálásának ellenőrzését.

Az alábbi ValuesController végpontok biztosítják a teszteléshez szükséges végpontokat:

[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 a Rick.Docs.Samples.RouteInfo NuGet-csomag biztosítja, és megjeleníti az útvonaladatokat.

Tesztelje az előző mintakódot az alábbi módszerek egyikével:

• Futtassa a mintát dotnet run használatával a https://localhost:5001 alapértelmezett URL-címmel.
• Futtassa a Visual Studióból származó mintát a 44398-ra beállított porttal a következő URL-címhez https://localhost:44398: .

Böngésző használata az F12-eszközökkel:

• Válassza az Értékek gombot, és tekintse át a fejléceket a Hálózat lapon.

• Válassza a PUT teszt gombot. A BEÁLLÍTÁSOK kérésének megjelenítésére vonatkozó utasításokért lásd: Megjelenítési beállítások kérések. A PUT-teszt két kérést hoz létre, egy BEÁLLÍTÁSOK elővizsgálati kérelmet és a PUT-kérést.

• Válassza ki a GetValues2 [DisableCors] gombot egy sikertelen CORS-kérés indításához. Ahogy a dokumentumban említettük, a válasz 200-as sikeres eredményt ad vissza, de a CORS-kérés nem történik meg. Válassza a Konzol fület a CORS-hiba megtekintéséhez. A böngészőtől függően a következőhöz hasonló hiba jelenik meg:

  A CORS-szabályzat letiltotta a 'https://cors1.azurewebsites.net/api/values/GetValues2' a 'https://cors3.azurewebsites.net' eredetből való elérését: A kért erőforráshoz nem tartozik 'Access-Control-Allow-Origin' fejléc. Ha egy átlátszatlan válasz megfelel az igényeinek, állítsa a kérés módját "no-cors" értékre, hogy lekérje az erőforrást, ha a CORS le van tiltva.

A CORS-kompatibilis végpontok egy eszközzel tesztelhetők, például curl vagy Fiddler. Eszköz használata esetén a fejlécben Origin megadott kérés forrásának különböznie kell a kérést fogadó szervertől. Ha a kérés nem keresztforrású a Origin fejléc értéke alapján:

• A cors middleware-nek nincs szüksége a kérés feldolgozására.
• A CORS-fejlécek nem jelennek meg a válaszban.

Az alábbi parancs a curl segítségével ad ki egy OPTIONS-kérést, mely tartalmazza az információt:

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

CORS tesztelése [EnableCors] attribútummal és RequireCors metódussal

Fontolja meg a következő kódot, amely végpont-útválasztást használva engedélyezi a CORS-t egyes végpontokra külön, a következő módszerrel 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();

Figyelje meg, hogy csak a /echo végpont használja a RequireCors a források közötti kérések engedélyezésére a hatályos szabályzat szerint. Az alábbi vezérlők az [EnableCors] attribútummal engedélyezik a CORS-t.

Az alábbiak TodoItems1Controller végpontokat biztosítanak a teszteléshez:

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

A Delete [EnableCors] és GET [EnableCors] gombok sikeresek, mert a végpontok rendelkeznek [EnableCors] és válaszolnak az előzetes kérelmekre. A többi végpont meghiúsul. A GET gomb sikertelen, mert a JavaScript a következőt küldi:

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

Az alábbiak TodoItems2Controller hasonló végpontokat biztosítanak, de explicit kódot tartalmaznak az OPTIONS-kérésekre való válaszadáshoz:

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

Az előző kód a minta Azure-ban való üzembe helyezésével tesztelhető. A Vezérlő legördülő listában válassza az Elővizsgálat , majd a Vezérlő beállítása lehetőséget. A TodoItems2Controller végpontokra irányuló összes CORS-hívás sikeres.

További erőforrások

• Forrásközi erőforrás-megosztás (CORS)
• IIS CORS-modul konfigurációs referencia