Konfigurera ASP.NET Core att fungera med proxyservrar och lastbalanserare

Av Chris Ross

I den rekommenderade konfigurationen för ASP.NET Core hanteras appen med hjälp av ASP.NET Core Module (ANCM) för IIS, Nginx eller Apache. Proxyservrar, lastbalanserare och andra nätverksinstallationer döljer ofta information om begäran innan den når appen:

• När HTTPS-begäranden proxas via HTTP förloras det ursprungliga schemat (HTTPS) och måste skickas vidare i en header.
• Eftersom en app tar emot en begäran från proxyn och inte dess sanna källa på Internet eller företagsnätverket, måste den ursprungliga klientens IP-adress också vidarebefordras i ett fält.

Den här informationen kan vara viktig vid bearbetning av begäranden, till exempel vid omdirigeringar, autentisering, länkgenerering, principutvärdering och klientgeolocation.

Appar som är avsedda att köras på en webbgrupp bör läsa Host ASP.NET Core i en webbgrupp.

Vidarebefordrade rubriker

Enligt konventionen vidarebefordrar proxyservrar information i HTTP-huvuden.

Rubrik	Beskrivning
X-Forwarded-For (XFF)	Innehåller information om klienten som initierade begäran och efterföljande proxyservrar i en kedja med proxyservrar. Den här parametern kan innehålla IP-adresser och, om du vill, portnummer. I en kedja med proxyservrar anger den första parametern klienten där begäran först gjordes. Efterföljande proxyidentifierare följer. Den sista proxyn i kedjan finns inte i listan med parametrar. Den senaste proxyns IP-adress, och eventuellt ett portnummer, är tillgängliga som fjärr-IP-adress på transportlagret.
X-Forwarded-Proto (XFP)	Värdet för det ursprungliga schemat, HTTP eller HTTPS. Värdet kan också vara en lista över scheman om begäran har passerat flera proxyservrar.
X-Forwarded-Host (XFH)	Det ursprungliga värdet för fältet Värdhuvud. Vanligtvis ändrar proxyservrar inte värdrubriken. Se Microsoft Security Advisory CVE-2018-0787 för information om en säkerhetsrisk med utökade privilegier som påverkar system där proxyn inte validerar eller begränsar värdhuvuden till kända goda värden.
X-Forwarded-Prefix	Den ursprungliga basstigen som efterfrågades av klienten. Den här huvudrubriken kan vara användbar för applikationer att korrekt generera URL:er, omdirigeringar eller länkar tillbaka till klienten.

Mellanprogram för vidarebefordrade rubriker, ForwardedHeadersMiddleware, läser dessa rubriker och fyller i de associerade fälten i HttpContext.

Mellanprogrammet uppdateras:

• HttpContext.Connection.RemoteIpAddress: Ställ in med hjälp av X-Forwarded-For-huvudvärdet. Ytterligare inställningar påverkar hur mellanprogrammet sätter RemoteIpAddress. För mer information, se alternativen för Vidarebefordrade rubriker-mellanprogram. De förbrukade värdena tas bort från X-Forwarded-Foroch det gamla värdet för HttpContext.Connection.RemoteIpAddress sparas i X-Original-For. Obs! Den här processen kan upprepas flera gånger om det finns flera värden i X-Forwarded-For/Proto/Host/Prefix, vilket resulterar i flera värden som flyttas till X-Original-*, inklusive den ursprungliga RemoteIpAddress/Host/Scheme/PathBase.
• HttpContext.Request.Scheme: Ställ in med hjälp av värdet i X-Forwarded-Proto-huvudet. Det förbrukade värdet tas bort från X-Forwarded-Protooch det gamla värdet för HttpContext.Request.Scheme sparas i X-Original-Proto.
• HttpContext.Request.Host: Ange med hjälp av värdet i X-Forwarded-Host-headern. Det förbrukade värdet tas bort från X-Forwarded-Hostoch det gamla värdet för HttpContext.Request.Host sparas i X-Original-Host.
• HttpContext.Request.PathBase: Ange med hjälp av X-Forwarded-Prefix-huvudvärdet. Det förbrukade värdet tas bort från X-Forwarded-Prefixoch det gamla värdet för HttpContext.Request.PathBase sparas i X-Original-Prefix.

Mer information om föregående finns i det här GitHub-ärendet.

Mellanprogrammet för vidarebefordrade rubriker standardinställningar kan konfigureras. För standardinställningarna:

• Det finns bara en proxy mellan appen och källan för begäranden.
• Endast loopback-adresser konfigureras för kända proxyservrar och kända nätverk.
• De vidarebefordrade rubrikerna heter X-Forwarded-For, X-Forwarded-Proto, X-Forwarded-Host och X-Forwarded-Prefix.
• Värdet ForwardedHeaders är ForwardedHeaders.None, och de önskade vidarebefordrarna måste anges här för att aktivera mellanvaran.

Inte alla nätverksenheter lägger till X-Forwarded-For- och X-Forwarded-Proto-huvuden utan ytterligare konfiguration. Läs installationstillverkarens vägledning om proxied-begäranden inte innehåller dessa rubriker när de når appen. Om installationen använder andra rubriknamn än X-Forwarded-For och X-Forwarded-Protoanger du alternativen ForwardedForHeaderName och ForwardedProtoHeaderName så att de matchar huvudnamnen som används av installationen. Mer information finns i Alternativ för vidarebefordrade huvudmellanprogram och Konfiguration för en proxy som använder olika rubriknamn.

IIS/IIS Express- och ASP.NET Core-modul

Vidarebefordrade rubriker Middleware är som standard aktiverad av IIS Integration Middleware när appen körs utanför processen bakom IIS och ASP.NET Core Module (ANCM) för IIS. Mellanprogram för vidarebefordrade headers aktiveras för att köras först i pipelinen för mellanprogram med en begränsad konfiguration som är specifik för ASP.NET Core modulen. Den begränsade konfigurationen beror på förtroendeproblem med vidarebefordrade huvuden, till exempel IP-förfalskning. Mellanprogrammet är konfigurerat för att vidarebefordra X-Forwarded-For- och X-Forwarded-Proto-huvuden och är begränsat till en enda localhost-proxy. Om ytterligare konfiguration krävs kan du läsa Vidarebefordrade rubriker Middleware-alternativen .

Andra scenarier för proxyserver och lastbalanserare

Förutom att använda IIS-integrering när du värd för out-of-process-, är mellanprogrammet för vidarebefordrade rubriker inte aktiverat som standard. Mellanprogram för vidarebefordrade rubriker måste vara aktiverat för att en app ska kunna hantera vidarebefordrade rubriker med UseForwardedHeaders. När du har aktiverat mellanprogrammet om inga ForwardedHeadersOptions har angetts för mellanprogrammet är standardvärdet ForwardedHeadersOptions.ForwardedHeadersForwardedHeaders.None.

Konfigurera mellanprogrammet med ForwardedHeadersOptions för att vidarebefordra X-Forwarded-For- och X-Forwarded-Proto-rubrikerna.

Middleware-ordning för vidarebefordrade rubriker

Vidarebefordrade rubriker Mellanprogram ska köras före andra mellanprogram. Den här ordningen säkerställer att mellanprogrammet som förlitar sig på vidarebefordrad rubrikinformation kan använda huvudvärdena för bearbetning. Mellanprogram för vidarebefordrade headers måste köras efter diagnostik och felhantering, men det måste köras innan UseHstsanropas.

using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseForwardedHeaders();
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseForwardedHeaders();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Du kan också anropa UseForwardedHeaders före diagnostik:

using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});

var app = builder.Build();

app.UseForwardedHeaders();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Not

Om inga ForwardedHeadersOptions anges eller tillämpas direkt på tilläggsmetoden med UseForwardedHeadersär standardrubrikerna som ska vidarebefordras ForwardedHeaders.None. Egenskapen ForwardedHeaders måste konfigureras med rubrikerna för att vidarebefordra.

Nginx-konfiguration

För att vidarebefordra X-Forwarded-For- och X-Forwarded-Proto-huvudena, se Värd ASP.NET Core på Linux med Nginx. Mer information finns i NGINX: Använda rubriken Vidarebefordrad.

Apache-konfiguration

X-Forwarded-For läggs till automatiskt. Mer information finns i Apache-modulen mod_proxy: Sidhuvuden för omvända proxybegäranden.

Alternativ för vidarebefordrade huvud mellanlagringsprogram

ForwardedHeadersOptions kontrollera beteendet hos vidarebefordrade Headers mellanmjukvara. I följande exempel ändras standardvärdena:

• Begränsar antalet poster i de vidarebefordrade rubrikerna till 2.
• Lägger till en känd proxyadress för 127.0.10.1.
• Ändrar det vidarebefordrade rubriknamnet från standardnamnet X-Forwarded-For till X-Forwarded-For-My-Custom-Header-Name.

using System.Net;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardLimit = 2;
    options.KnownProxies.Add(IPAddress.Parse("127.0.10.1"));
    options.ForwardedForHeaderName = "X-Forwarded-For-My-Custom-Header-Name";
});

var app = builder.Build();

app.UseForwardedHeaders();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Alternativ	Beskrivning
AllowedHosts	Begränsar värdar efter X-Forwarded-Host-huvudet till de värden som anges. Värden jämförs med ordningstal-ignorera-skiftläge. Portnummer måste undantas. Om listan är tom, tillåts alla värdar. Ett jokertecken på toppnivå * tillåter alla värdar som inte är tomma. Jokertecken för underdomäner tillåts men matchar inte rotdomänen. Till exempel matchar *.contoso.com underdomänen foo.contoso.com men inte rotdomänen contoso.com. Unicode-värdnamn tillåts men konverteras till Punycode- för matchning. IPv6-adresser måste innehålla avgränsningsparenteser och vara i konventionell form (till exempel [ABCD:EF01:2345:6789:ABCD:EF01:2345:6789]). IPv6-adresser särbehandlas inte för att verifiera logisk likvärdighet mellan olika format och ingen kanonisering utförs. Om det inte går att begränsa tillåtna värdar kan en cyberattacker tillåta förfalskning av länkar som genereras av tjänsten. Standardvärdet är ett tomt IList<string>.
ForwardedForHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XForwardedForHeaderName. Det här alternativet används när proxyn/vidarebefordraren inte använder X-Forwarded-For-huvudet, men använder en annan rubrik för att vidarebefordra informationen. Standardvärdet är X-Forwarded-For.
ForwardedHeaders	Identifierar vilka vidarebefordrare som ska bearbetas. Se ForwardedHeaders Enum för listan över fält som gäller. Typiska värden som tilldelats den här egenskapen är ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto. Standardvärdet är ForwardedHeaders.None.
ForwardedHostHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XForwardedHostHeaderName. Det här alternativet används när proxyn/vidarebefordraren inte använder X-Forwarded-Host-huvudet, men använder en annan rubrik för att vidarebefordra informationen. Standardvärdet är X-Forwarded-Host.
ForwardedProtoHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XForwardedProtoHeaderName. Det här alternativet används när proxyn/vidarebefordraren inte använder X-Forwarded-Proto-huvudet, men använder en annan rubrik för att vidarebefordra informationen. Standardvärdet är X-Forwarded-Proto.
ForwardLimit	Begränsar antalet poster i rubrikerna som bearbetas. Ange till null för att inaktivera gränsen, men detta bör endast göras om KnownProxies eller KnownNetworks har konfigurerats. Att ange ett icke-null värde är en försiktighetsåtgärd (men inte en garanti) för att skydda mot felkonfigurerade proxyservrar och skadliga begäranden som kommer från sidokanaler i nätverket. Vidarebefordrade rubriker Mellanprogram bearbetar rubriker i omvänd ordning från höger till vänster. Om standardvärdet (1) används bearbetas endast det högra värdet från rubrikerna om inte värdet för ForwardLimit ökas. Standardvärdet är 1.
KnownNetworks	Adressintervall för kända nätverk som du kan acceptera vidarebefordrade huvuden från. Ange IP-intervall med CIDR-notation (Classless Interdomain Routing). Om servern använder socketar med dubbla lägen anges IPv4-adresser i IPv6-format (till exempel 10.0.0.1 i IPv4 som representeras i IPv6 som ::ffff:10.0.0.1). Se IPAddress.MapToIPv6. Kontrollera om det här formatet krävs genom att titta på HttpContext.Connection.RemoteIpAddress. Standardvärdet är en IList<IPNetwork> som innehåller en enda post för new IPNetwork(IPAddress.Loopback, 8).
KnownProxies	Adresser till kända proxyservrar som du kan acceptera vidarebefordrade huvuden från. Använd KnownProxies för att ange exakta IP-adressmatchningar. Om servern använder socketar med dubbla lägen anges IPv4-adresser i IPv6-format (till exempel 10.0.0.1 i IPv4 som representeras i IPv6 som ::ffff:10.0.0.1). Se IPAddress.MapToIPv6. Kontrollera om det här formatet krävs genom att titta på HttpContext.Connection.RemoteIpAddress. Standardvärdet är en IList<IPAddress> som innehåller en enda post för IPAddress.IPv6Loopback.
OriginalForHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XOriginalForHeaderName. Standardvärdet är X-Original-For.
OriginalHostHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XOriginalHostHeaderName. Standardvärdet är X-Original-Host.
OriginalProtoHeaderName	Använd rubriken som anges av den här egenskapen i stället för den som anges av ForwardedHeadersDefaults.XOriginalProtoHeaderName. Standardvärdet är X-Original-Proto.
RequireHeaderSymmetry	Kräv att antalet rubrikvärden är synkroniserade när ForwardedHeadersOptions.ForwardedHeaders bearbetas. Standardvärdet i ASP.NET Core 1.x är true. Standardvärdet i ASP.NET Core 2.0 eller senare är false.

Scenarier och användningsfall

När det inte går att lägga till vidarebefordrade headers och alla förfrågningar är säkra

I vissa fall kanske det inte går att inkludera vidarebefordrade headers i de begäranden som skickas till appen. Om proxyn framtvingar att alla offentliga externa begäranden är HTTPS kan schemat ställas in manuellt innan du använder någon typ av mellanprogram:

using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});

var app = builder.Build();

app.Use((context, next) =>
{
    context.Request.Scheme = "https";
    return next(context);
});

app.UseForwardedHeaders();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Den här koden kan inaktiveras med en miljövariabel eller annan konfigurationsinställning i en utvecklings- eller mellanlagringsmiljö:

using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});

var app = builder.Build();

if (!app.Environment.IsProduction())
{
    app.Use((context, next) =>
    {
        context.Request.Scheme = "https";
        return next(context);
    });
}

app.UseForwardedHeaders();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Arbeta med sökvägsbas och proxyservrar som ändrar begärandesökvägen

Vissa proxyservrar skickar sökvägen intakt men med en appbassökväg som ska tas bort så att routningen fungerar korrekt. UsePathBaseExtensions.UsePathBase mellanprogram delar upp sökvägen i HttpRequest.Path och appens bassökväg i HttpRequest.PathBase.

Om /foo är appbassökvägen för en proxysökväg som skickas som /foo/api/1anger mellanprogrammet Request.PathBase till /foo och Request.Path till /api/1 med följande kommando:

app.UsePathBase("/foo");
// ...
app.UseRouting();

Anteckning

När du använder WebApplication (se Migrera från ASP.NET Core 5.0 till 6.0) måste app.UseRouting anropas efter UsePathBase så att routningsmellanprogrammet kan observera den ändrade sökvägen innan du matchar vägar. Annars matchas vägar innan sökvägen skrivs om av UsePathBase enligt beskrivningen i artiklarna Middleware Ordering och Routning.

Den ursprungliga sökvägen och sökvägsbasen tillämpas igen när mellanprogrammet anropas igen i omvänd ordning. Mer information om orderbearbetning av mellanprogram finns i ASP.NET Core Middleware.

Om proxyn trimmar sökvägen (till exempel vidarebefordran /foo/api/1 till /api/1) korrigerar du omdirigeringar och länkar genom att ange begärans PathBase-egenskap:

app.Use((context, next) =>
{
    context.Request.PathBase = new PathString("/foo");
    return next(context);
});

Om proxyn lägger till sökvägsdata tar du bort en del av sökvägen för att åtgärda omdirigeringar och länkar med hjälp av StartsWithSegments och tilldela till egenskapen Path:

app.Use((context, next) =>
{
    if (context.Request.Path.StartsWithSegments("/foo", out var remainder))
    {
        context.Request.Path = remainder;
    }

    return next(context);
});

Konfiguration för en proxy som använder olika rubriknamn

Om proxyn inte använder rubriker med namnet X-Forwarded-For och X-Forwarded-Proto för att vidarebefordra proxyadressen/porten och ursprunglig schemainformation anger du alternativen ForwardedForHeaderName och ForwardedProtoHeaderName för att matcha huvudnamnen som används av proxyn:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedForHeaderName = "HeaderNamUsedByProxy_X-Forwarded-For_Header";
    options.ForwardedProtoHeaderName = "HeaderNamUsedByProxy_X-Forwarded-Proto_Header";
});

var app = builder.Build();

app.UseForwardedHeaders();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Vidarebefordra schemat för Linux och icke-IIS omvänd proxytjänst

Appar som anropar UseHttpsRedirection och UseHsts placerar en webbplats i en oändlig loop om den distribueras till en Azure Linux App Service, en virtuell Azure Linux-dator (VM) eller bakom någon annan omvänd proxyserver förutom IIS. TLS avslutas av den omvända proxyn och Kestrel blir inte medvetet om rätt begärandeschema. OAuth och OIDC misslyckas också i den här konfigurationen eftersom de genererar felaktiga omdirigeringar. UseIISIntegration lägger till och konfigurerar vidarebefordrade huvudmellanprogram när de körs bakom IIS, men det finns ingen matchande automatisk konfiguration för Linux (Apache- eller Nginx-integrering).

Om du vill vidarebefordra schemat från proxyn i icke-IIS-situationer aktiverar du mellanprogrammet för vidarebefordrade rubriker genom att ange ASPNETCORE_FORWARDEDHEADERS_ENABLED till true. Varning! Den här flaggan använder inställningar som är utformade för molnmiljöer och aktiverar inte funktioner som KnownProxies option för att begränsa vilka IP-adresser som vidarebefordrare accepteras från.

Vidarebefordring av certifikat

Blått

Information om hur du konfigurerar Azure App Service för vidarebefordring av certifikat finns i Konfigurera ömsesidig TLS-autentisering för Azure App Service. Följande vägledning gäller för att konfigurera ASP.NET Core-appen.

• Konfigurera Mellanprogram för vidarebefordran av certifikat för för att ange det rubriknamn som Azure använder. Lägg till följande kod för att konfigurera den header från vilken middleware bygger ett certifikat.
• Anropa UseCertificateForwarding innan anropet till UseAuthentication.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddCertificateForwarding(options =>
    options.CertificateHeader = "X-ARR-ClientCert");

var app = builder.Build();

app.UseCertificateForwarding();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();
app.UseAuthentication();

app.MapRazorPages();

app.Run();

Andra webbproxytjänster

Om en proxy används som inte är IIS eller Azure App Service's Application Request Routing (ARR) konfigurerar du proxyn för att vidarebefordra certifikatet som den tog emot i ett HTTP-huvud.

• Konfigurera Mellanprogrammet för vidarebefordran av certifikat för att ange namnet på rubriken. Lägg till följande kod för att konfigurera headern från vilket mellanprogrammet skapar ett certifikat.
• Anropa UseCertificateForwarding innan anropet till UseAuthentication.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddCertificateForwarding(options =>
    options.CertificateHeader = "YOUR_CERTIFICATE_HEADER_NAME");

var app = builder.Build();

app.UseCertificateForwarding();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();
app.UseAuthentication();

app.MapRazorPages();

app.Run();

Om proxyn inte base64-kodar certifikatet, vilket är fallet med Nginx, anger du alternativet HeaderConverter. Tänk på följande exempel:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddCertificateForwarding(options =>
{
    options.CertificateHeader = "YOUR_CUSTOM_HEADER_NAME";
    options.HeaderConverter = (headerValue) =>
    {
        // Conversion logic to create an X509Certificate2.
        var clientCertificate = ConversionLogic.CreateAnX509Certificate2();
        return clientCertificate;
    };
});

var app = builder.Build();

app.UseCertificateForwarding();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();
app.UseAuthentication();

app.MapRazorPages();

app.Run();

Felsöka

När huvuden inte vidarebefordras som förväntat aktiverar du loggning på nivå debugoch HTTP-begärandeloggning. UseHttpLogging måste anropas efter UseForwardedHeaders:

using Microsoft.AspNetCore.HttpLogging;
using Microsoft.AspNetCore.HttpOverrides;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddHttpLogging(options =>
{
    options.LoggingFields = HttpLoggingFields.RequestPropertiesAndHeaders;
});

builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});

var app = builder.Build();

app.UseForwardedHeaders();
app.UseHttpLogging();

app.Use(async (context, next) =>
{
    // Connection: RemoteIp
    app.Logger.LogInformation("Request RemoteIp: {RemoteIpAddress}",
        context.Connection.RemoteIpAddress);

    await next(context);
});

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Om det finns flera värden i ett visst huvud bearbetar Vidarebefordrade rubriker Mellanprogram rubriker i omvänd ordning från höger till vänster. Standardvärdet ForwardLimit är 1 (ett), så endast det högra värdet från rubrikerna bearbetas om inte värdet för ForwardLimit ökas.

Begärans ursprungliga fjärr-IP måste matcha ett inlägg i KnownProxies- eller KnownNetworks-listorna innan vidarebefordrade rubriker bearbetas. Detta begränsar sidhuvudets förfalskning genom att inte acceptera vidarebefordrare från ej betrodda proxyservrar. När en okänd proxy identifieras anger loggning proxyns adress:

September 20th 2018, 15:49:44.168 Unknown proxy: 10.0.0.100:54321

I föregående exempel är 10.0.0.100 en proxyserver. Om servern är en betrodd proxy lägger du till serverns IP-adress i KnownProxieseller lägger till ett betrott nätverk i KnownNetworks. För ytterligare information, se avsnittet Mellanprogram för vidarebefordrade rubriker, alternativ.

using Microsoft.AspNetCore.HttpOverrides;
using System.Net;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders =
        ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
    options.KnownProxies.Add(IPAddress.Parse("10.0.0.100"));
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseForwardedHeaders();
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseForwardedHeaders();
}

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

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Om du vill visa loggarna lägger du till "Microsoft.AspNetCore.HttpLogging": "Information" i filen appsettings.Development.json:

{
  "DetailedErrors": true,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "Microsoft.AspNetCore.HttpLogging": "Information"
    }
  }
}

Viktig

Tillåt endast betrodda proxyservrar och nätverk att vidarebefordra huvuden. Annars är IP-förfalsknings attacker möjliga.

Ytterligare resurser

• Host ASP.NET Core i ett webbkluster
• Microsofts säkerhetsråd CVE-2018-0787: ASP.NET Core eskalering av privilegieresårbarhet
• YARP: Ännu en omvänd proxy