Skydda en ASP.NET Core Blazor Web App med Microsoft Entra ID

Den här artikeln beskriver hur du skyddar en Blazor Web App med Microsofts identitetsplattform med Microsoft-webbpaket Identity för Microsoft Entra-ID med hjälp av en exempelapp.

app.MapGet("/weather-forecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
}).RequireAuthorization();

jwtOptions.Authority = "{AUTHORITY}";

jwtOptions.Authority = "https://sts.windows.net/aaaabbbb-0000-cccc-1111-dddd2222eeee/";

jwtOptions.Authority = "https://login.microsoftonline.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0/";

jwtOptions.Audience = "{AUDIENCE}";

jwtOptions.Audience = "api://11112222-bbbb-3333-cccc-4444dddd5555";

jwtOptions.Audience = "https://contoso.onmicrosoft.com/11112222-bbbb-3333-cccc-4444dddd5555";

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.Domain = "{DIRECTORY NAME}.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "{TENANT ID}";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = [ "{APP ID URI}/Weather.Get" ];
    })
    .AddDistributedTokenCaches();

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.Domain = "contoso.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "aaaabbbb-0000-cccc-1111-dddd2222eeee";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = [ "api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get" ];
    })
    .AddDistributedTokenCaches();

app.MapGet("/weather-forecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
}).RequireAuthorization();

jwtOptions.Authority = "{AUTHORITY}";

jwtOptions.Authority = "https://sts.windows.net/aaaabbbb-0000-cccc-1111-dddd2222eeee/";

jwtOptions.Authority = "https://login.microsoftonline.com/aaaabbbb-0000-cccc-1111-dddd2222eeee/v2.0/";

jwtOptions.Audience = "{AUDIENCE}";

jwtOptions.Audience = "api://11112222-bbbb-3333-cccc-4444dddd5555";

jwtOptions.Audience = "https://contoso.onmicrosoft.com/11112222-bbbb-3333-cccc-4444dddd5555";

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "{CLIENT ID (BLAZOR APP)}";
        msIdentityOptions.Domain = "{DIRECTORY NAME}.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "{TENANT ID}";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "{BASE ADDRESS}";
        configOptions.Scopes = [ "{APP ID URI}/Weather.Get" ];
    })
    .AddDistributedTokenCaches();

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(msIdentityOptions =>
    {
        msIdentityOptions.CallbackPath = "/signin-oidc";
        msIdentityOptions.ClientId = "00001111-aaaa-2222-bbbb-3333cccc4444";
        msIdentityOptions.Domain = "contoso.onmicrosoft.com";
        msIdentityOptions.Instance = "https://login.microsoftonline.com/";
        msIdentityOptions.ResponseType = "code";
        msIdentityOptions.TenantId = "aaaabbbb-0000-cccc-1111-dddd2222eeee";
    })
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("DownstreamApi", configOptions =>
    {
        configOptions.BaseUrl = "https://localhost:7277";
        configOptions.Scopes = [ "api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get" ];
    })
    .AddDistributedTokenCaches();

Återanropssökvägen (CallbackPath) måste matcha den omdirigerings-URI (sökväg för återanrop för inloggning) som konfigurerades vid registreringen av programmet i Entra- eller Azure-portalen. Sökvägar konfigureras i avsnittet Autentisering för appregistrering. Standardvärdet för CallbackPath är /signin-oidc för en registrerad omdirigerings-URI för https://localhost/signin-oidc (en port krävs inte).

SignedOutCallbackPath är sökvägen för begäran inom appens bassökväg som fångas upp av OpenID Connect-hanteraren där användaragenten först returneras efter utloggning från Entra. Exempelappen anger inte något värde för sökvägen eftersom standardvärdet "/signout-callback-oidc" används. Efter att ha avlyssnat begäran omdirigerar OpenID Connect-hanteraren till SignedOutRedirectUri eller RedirectUri, om det är angivet.

Konfigurera den utloggade återställningssökvägen i appens Entra-registrering. I Entra- eller Azure-portalen anger du sökvägen i Web-plattformskonfigurationens omdirigerings-URI poster:

https://localhost/signout-callback-oidc

Om du inte lägger till URI för utloggningsåterkallningssökvägen i appens registrering i Entra, kommer Entra att vägra omdirigera användaren tillbaka till appen och istället bara be dem stänga webbläsarfönstret.

Upprätta klienthemligheten

Det här avsnittet gäller endast serverprojektet för Blazor Web App.

Använd någon av eller båda av följande metoder för att tillhandahålla klienthemligheten till appen:

• Secret Manager-verktyget: Secret Manager-verktyget lagrar privata data på den lokala datorn och används endast under lokal utveckling.
• Azure Key Vault-: Du kan lagra klienthemligheten i ett nyckelvalv för användning i alla miljöer, inklusive för utvecklingsmiljön när du arbetar lokalt. Vissa utvecklare föredrar att använda nyckelvalv för mellanlagrings- och produktionsdistributioner och använder Secret Manager-verktyget för lokal utveckling.

Vi rekommenderar starkt att du undviker att lagra klienthemligheter i projektkod eller konfigurationsfiler. Använd säkra autentiseringsflöden, till exempel någon av eller båda metoderna i det här avsnittet.

Secret Manager-verktyget

Verktyget Secret Manager kan lagra serverappens klienthemlighet under konfigurationsnyckeln AzureAd:ClientSecret.

Serverappen Blazor har inte initierats för Secret Manager-verktyget. Använd ett kommandogränssnitt, till exempel PowerShell-kommandogränssnittet Developer i Visual Studio, för att köra följande kommando. Innan du kör kommandot ändrar du katalogen med kommandot cd till serverprojektets katalog. Kommandot upprättar en identifierare för användarhemligheter (<UserSecretsId>) i serverappens projektfil, som används internt av verktyget för att spåra hemligheter för appen:

dotnet user-secrets init

Kör följande kommando för att ange klienthemligheten. Platshållaren {SECRET} är klienthemligheten som hämtas från appens Entra-registrering:

dotnet user-secrets set "AzureAd:ClientSecret" "{SECRET}"

Om du använder Visual Studio kan du bekräfta att hemligheten har angetts genom att högerklicka på serverprojektet i Solution Explorer och välja Hantera användarhemligheter.

Azure 密钥保管库

Azure Key Vault- är en säker metod för att tillhandahålla appens klienthemlighet till appen.

Information om hur du skapar ett nyckelvalv och anger en klienthemlighet finns i Om Azure Key Vault-hemligheter (Azure-dokumentation), som korslänkar resurser för att komma igång med Azure Key Vault. Om du vill implementera koden i det här avsnittet registrerar du nyckelvalvets URI och det hemliga namnet från Azure när du skapar nyckelvalvet och hemligheten. I exemplet i det här avsnittet är det hemliga namnet "BlazorWebAppEntraClientSecret".

När du upprättar nyckelvalvet i Entra- eller Azure-portalen:

• Konfigurera nyckelvalvet så att det använder rollbaserad åtkomstkontroll i Azure (RABC). Om du inte arbetar i ett virtuellt Azure-nätverk, inklusive för lokal utveckling och testning, bekräftar du att offentlig åtkomst i nätverkssteget är aktiverad (markerad). Om du aktiverar offentlig åtkomst exponeras endast nyckelvalvets slutpunkt. Autentiserade konton krävs fortfarande för åtkomst.

• Skapa en Azure Managed Identity (eller lägg till en roll i den befintliga Managed Identity som du planerar att använda) med rollen Användare av Key Vault-hemligheter. Tilldela den hanterade Identity till den Azure App Service som är värd för distributionen: Inställningar>Identity>Användartilldelad>Lägg till.

  Obs

  Om du även planerar att köra en app lokalt med en behörig användare för åtkomst till nyckelvalvet med hjälp av Azure CLI eller Visual Studio Azure Service Authentication lägger du till ditt Azure-användarkonto för utvecklare i Åtkomstkontroll (IAM) med rollen Key Vault Secrets User . Om du vill använda Azure CLI via Visual Studio, kör kommandot az login från Utvecklar-PowerShell-panelen och följ anvisningarna för att autentisera med tenant.

Om du vill implementera koden i det här avsnittet registrerar du nyckelvalvets URI (exempel: "https://contoso.vault.azure.net/", avslutande snedstreck krävs) och det hemliga namnet (exempel: "BlazorWebAppEntraClientSecret") från Azure när du skapar nyckelvalvet och hemligheten.

Lägg till följande AzureHelper-klass i serverprojektet. Metoden GetKeyVaultSecret hämtar en hemlighet från ett nyckelvalv. Justera namnområdet (BlazorSample.Helpers) så att det matchar projektets namnområdesschema.

Helpers/AzureHelper.cs:

using Azure.Core;
using Azure.Security.KeyVault.Secrets;

namespace BlazorWebAppEntra.Helpers;

public static class AzureHelper
{
    public static string GetKeyVaultSecret(string vaultUri, 
        TokenCredential credential, string secretName)
    {
        var client = new SecretClient(new Uri(vaultUri), credential);
        var secret = client.GetSecretAsync(secretName).Result;

        return secret.Value.Value;
    }
}

Om tjänster registreras i serverprojektets Program-fil hämtar och tillämpar du klienthemligheten med hjälp av följande kod:

TokenCredential? credential;

if (builder.Environment.IsProduction())
{
    credential = new ManagedIdentityCredential("{MANAGED IDENTITY CLIENT ID}");
}
else
{
    // Local development and testing only
    DefaultAzureCredentialOptions options = new()
    {
        // Specify the tenant ID to use the dev credentials when running the app locally
        // in Visual Studio.
        VisualStudioTenantId = "{TENANT ID}",
        SharedTokenCacheTenantId = "{TENANT ID}"
    };

    credential = new DefaultAzureCredential(options);
}

Där <xref:Microsoft.Identity.Web.MicrosoftIdentityOptions> är inställda, ring GetKeyVaultSecret för att ta emot och tilldela appens klienthemlighet:

msIdentityOptions.ClientSecret = AzureHelper.GetKeyVaultSecret("{VAULT URI}", 
    credential, "{SECRET NAME}");

{MANAGED IDENTITY CLIENT ID}: Azure Hanterad Identity Klient-ID (GUID).

{TENANT ID}: Katalog-ID (hyresgäst). Exempel: aaaabbbb-0000-cccc-1111-dddd2222eeee

{VAULT URI}: Nyckelvalvs-URI. Inkludera det avslutande snedstrecket på URI:n. Exempel: https://contoso.vault.azure.net/

{SECRET NAME}: Hemligt namn. Exempel: BlazorWebAppEntraClientSecret

Konfigurationen används för att underlätta tillhandahållandet av dedikerade nyckelvalv och hemliga namn baserat på appens miljökonfigurationsfiler. Du kan till exempel ange olika konfigurationsvärden för appsettings.Development.json under utveckling, appsettings.Staging.json vid mellanlagring och appsettings.Production.json för produktionsdistributionen. Mer information finns i ASP.NET Core Blazor configuration.

Ange konfiguration med JSON-konfigurationsprovidern (appinställningar)

Exempellösningsprojekten konfigurerar Microsoft Identity Web- och JWT-ägarautentisering i sina Program filer för att göra konfigurationsinställningarna identifierbara med C#-automatisk komplettering. Professionella appar använder vanligtvis en konfigurationsprovider för att konfigurera OIDC-alternativ, till exempel JSON-standardkonfigurationsprovidern. JSON-konfigurationsprovidern läser in konfigurationen från appinställningarsfiler appsettings.json/appsettings.{ENVIRONMENT}.json, där {ENVIRONMENT} platshållaren är appens körningsmiljö. Följ anvisningarna i det här avsnittet om du vill använda appinställningar för konfiguration.

Lägg till följande JSON-konfiguration i appens inställningsfil (appsettings.json) i BlazorWebAppEntra projektet:

{
  "AzureAd": {
    "CallbackPath": "/signin-oidc",
    "ClientId": "{CLIENT ID (BLAZOR APP)}",
    "Domain": "{DIRECTORY NAME}.onmicrosoft.com",
    "Instance": "https://login.microsoftonline.com/",
    "ResponseType": "code",
    "TenantId": "{TENANT ID}"
  },
  "DownstreamApi": {
    "BaseUrl": "{BASE ADDRESS}",
    "Scopes": [ "{APP ID URI}/Weather.Get" ]
  }
}

Uppdatera platshållarna i föregående konfiguration så att de matchar de värden som appen använder i Program filen:

• {CLIENT ID (BLAZOR APP)}: Applikations-ID (klient).
• {DIRECTORY NAME}: Katalognamnet för klientdomänen (för utgivaren).
• {TENANT ID}: Katalog-ID (hyresgäst).
• {BASE ADDRESS}: Webb-API:ets basadress.
• {APP ID URI}: App-ID-URI:n för webb-API-omfång. Något av följande format används, där {CLIENT ID (WEB API)} platshållaren är klient-ID:t för webb-API:ets Entra-registrering, och {DIRECTORY NAME} platshållaren är katalognamnet för klientdomänen (utgivare) (exempel: contoso).
  • ME-ID klientorganisationsformat: api://{CLIENT ID (WEB API)}
  • B2C-klientformat: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID (WEB API)}

Exempel:

"AzureAd": {
  "CallbackPath": "/signin-oidc",
  "ClientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "Domain": "contoso.onmicrosoft.com",
  "Instance": "https://login.microsoftonline.com/",
  "ResponseType": "code",
  "TenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee"
},
"DownstreamApi": {
  "BaseUrl": "https://localhost:7277",
  "Scopes": [ "api://11112222-bbbb-3333-cccc-4444dddd5555/Weather.Get" ]
}

Uppdatera andra värden i föregående konfiguration så att de matchar anpassade/icke-standardvärden som används i Program filen.

Konfigurationen hämtas automatiskt av autentiseringsverktyget.

Gör följande ändringar i Program filen:

builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
-   .AddMicrosoftIdentityWebApp(msIdentityOptions =>
-   {
-       msIdentityOptions.CallbackPath = "...";
-       msIdentityOptions.ClientId = "...";
-       msIdentityOptions.Domain = "...";
-       msIdentityOptions.Instance = "...";
-       msIdentityOptions.ResponseType = "...";
-       msIdentityOptions.TenantId = "...";
-   })
+   .AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"))
    .EnableTokenAcquisitionToCallDownstreamApi()
-   .AddDownstreamApi("DownstreamApi", configOptions =>
-   {
-       configOptions.BaseUrl = "...";
-       configOptions.Scopes = [ "..." ];
-   })
+   .AddDownstreamApi("DownstreamApi", builder.Configuration.GetSection("DownstreamApi"))
    .AddDistributedTokenCaches();

MinimalApiJwt I projektet lägger du till följande konfiguration av appinställningar i appsettings.json filen:

"Authentication": {
  "Schemes": {
    "Bearer": {
      "Authority": "https://sts.windows.net/{TENANT ID (WEB API)}/",
      "ValidAudiences": [ "{APP ID URI (WEB API)}" ]
    }
  }
},

Uppdatera platshållarna i föregående konfiguration så att de matchar de värden som appen använder i Program filen:

• {TENANT ID (WEB API)}: Hyresgästens ID för webb-API:et.
• {APP ID URI (WEB API)}: App-ID-URI:n för webb-API:et.

Myndighetsformat använder följande mönster:

• ME-ID klienttyp: https://sts.windows.net/{TENANT ID}/
• B2C-klienttyp: https://login.microsoftonline.com/{TENANT ID}/v2.0/

Målgruppsformat använder följande mönster ({CLIENT ID} är klient-ID:t för webb-API:et, {DIRECTORY NAME} är katalognamnet, till exempel contoso):

• ME-ID klienttyp: api://{CLIENT ID}
• B2C-klienttyp: https://{DIRECTORY NAME}.onmicrosoft.com/{CLIENT ID}

Konfigurationen hämtas automatiskt av JWT-ägarautentiseringsverktyget.

Ta bort följande rader från Program filen:

- jwtOptions.Authority = "...";
- jwtOptions.Audience = "...";

Mer information om konfiguration finns i följande resurser:

• Konfiguration i ASP.NET Core
• ASP.NET Core Blazor konfiguration

Använd en leverantör av distribuerad tokencache för produktion

Minnesinterna distribuerade tokencacher skapas vid anrop av <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.DistributedTokenCacheAdapterExtension.AddDistributedTokenCaches%2A> för att säkerställa att det finns en basimplementering tillgänglig för cachelagring av distribuerade token.

Produktionswebbappar och webb-API:er bör använda en cache för distribuerad token för produktion (till exempel : Redis, Microsoft SQL Server, Microsoft Azure Cosmos DB).

builder.Services.AddInMemoryTokenCaches();

AddDistributedMemoryCache lägger till en standardimplementering av IDistributedCache som lagrar cacheobjekt i minnet, som används av Microsoft Identity Web för cachelagring av token.

Cacheminnet för distribuerad token konfigureras av <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions>:

• Under utveckling i felsökningssyfte kan du inaktivera L1-cachen genom att ange <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions.DisableL1Cache%2A> till true. Se till att återställa den till false för produktion.
• Ange den maximala storleken på L1-cachen med L1CacheOptions.SizeLimit för att förhindra att cacheminnet överskrider serverns minne. Standardvärdet är 500 MB.
• Under utveckling i felsökningssyfte kan du inaktivera tokenkryptering i vila genom att ange <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions.Encrypt%2A> till false, vilket är standardvärdet. Se till att återställa den till true för produktion.
• Ange borttagning av token från cachen med SlidingExpiration. Standardvärdet är 1 timme.
• Mer information, inklusive vägledning om återanrop för L2-cachefel (<xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions.OnL2CacheFailure%2A>) och asynkrona L2-cacheskrivningar (<xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions.EnableAsyncL2Write%2A>), finns i <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions> och Token cache serialisering: Distribuerade tokencacheminnen.

builder.Services.AddDistributedMemoryCache();

builder.Services.Configure<MsalDistributedTokenCacheAdapterOptions>(
    options => 
    {
      // The following lines that are commented out reflect
      // default values. We recommend overriding the default
      // value of Encrypt to encrypt tokens at rest.

      //options.DisableL1Cache = false;
      //options.L1CacheOptions.SizeLimit = 500 * 1024 * 1024;
      options.Encrypt = true;
      //options.SlidingExpiration = TimeSpan.FromHours(1);
    });

AddDistributedMemoryCache kräver en paketreferens till Microsoft.Extensions.Caching.Memory NuGet-paketet.

Information om hur du konfigurerar en distribuerad cacheprovider för produktion finns i Distribuerad cachelagring i ASP.NET Core.

Mer information finns i Token cache serialisering: Distribuerade cacheminnen. De kodexempel som visas gäller dock inte för ASP.NET Core-appar som konfigurerar distribuerade cacheminnen via AddDistributedMemoryCache, inte <xref:Microsoft.Identity.Web.TokenCacheExtensions.AddDistributedTokenCache%2A>.

Använd en delad dataskyddsnyckelring i produktion så att instanser av appen över servrar i en webbserverfarm kan dekryptera tokenen när <xref:Microsoft.Identity.Web.TokenCacheProviders.Distributed.MsalDistributedTokenCacheAdapterOptions.Encrypt%2A?displayProperty=nameWithType> är inställd på true.

options.Encrypt = false;

I följande exempel visas hur du använder Azure Blob Storage och Azure Key Vault (PersistKeysToAzureBlobStorage/ProtectKeysWithAzureKeyVault) för den delade nyckelringen. Tjänstkonfigurationerna är basfallsscenarier i demonstrationssyfte. Innan du distribuerar produktionsappar kan du bekanta dig med Azure-tjänsterna och använda metodtips med hjälp av Azure-tjänsternas dedikerade dokumentationsuppsättningar, som är länkade i slutet av det här avsnittet.

Bekräfta förekomsten av följande paket i serverprojektet för Blazor Web App:

• Azure.Extensions.AspNetCore.DataProtection.Blobs
• Azure.Extensions.AspNetCore.DataProtection.Keys

Följande kod implementeras vanligtvis samtidigt som en leverantör av distribuerad tokencache för produktion implementeras. Andra alternativ, både i Azure och utanför Azure, är tillgängliga för hantering av dataskyddsnycklar över flera appinstanser, men exempelappen visar hur du använder Azure-tjänster.

Konfigurera Azure Blob Storage för att underhålla dataskyddsnycklar. Följ riktlinjerna i Nyckellagringsprovidrar i ASP.NET Core.

Konfigurera Azure Key Vault för att kryptera de vilande dataskyddsnycklarna. Följ riktlinjerna i Konfigurera ASP.NET Core Data Protection.

Använd följande kod i Program filen där tjänster är registrerade:

TokenCredential? credential;

if (builder.Environment.IsProduction())
{
    credential = new ManagedIdentityCredential("{MANAGED IDENTITY CLIENT ID}");
}
else
{
    // Local development and testing only
    DefaultAzureCredentialOptions options = new()
    {
        // Specify the tenant ID to use the dev credentials when running the app locally
        // in Visual Studio.
        VisualStudioTenantId = "{TENANT ID}",
        SharedTokenCacheTenantId = "{TENANT ID}"
    };

    credential = new DefaultAzureCredential(options);
}

builder.Services.AddDataProtection()
    .SetApplicationName("BlazorWebAppEntra")
    .PersistKeysToAzureBlobStorage(new Uri("{BLOB URI}"), credential)
    .ProtectKeysWithAzureKeyVault(new Uri("{KEY IDENTIFIER}"), credential);

Du kan skicka valfritt appnamn till SetApplicationName. Bekräfta bara att alla appdistributioner använder samma värde.

{MANAGED IDENTITY CLIENT ID}: Azure Hanterad Identity Klient-ID (GUID).

{TENANT ID}: Hyresgäst-ID.

{BLOB URI}: Fullständig URI till nyckelfilen. URI:n genereras av Azure Storage när du skapar nyckelfilen. Använd inte en SAS.

{KEY IDENTIFIER}: Azure Key Vault-nyckelidentifierare som används för nyckelkryptering. Med en åtkomstprincip kan programmet komma åt nyckelvalvet med Getbehörigheterna , Unwrap Keyoch Wrap Key . Versionen av nyckeln hämtas från nyckeln i Entra- eller Azure-portalen när den har skapats. Om du aktiverar autorotation av nyckelvalvsnyckeln kontrollerar du att du använder en versionslös nyckelidentifierare i appens nyckelvalvskonfiguration, där inget nyckel-GUID placeras i slutet av identifieraren (exempel: https://contoso.vault.azure.net/keys/data-protection).

Du kan också konfigurera appen så att den anger värdena från appinställningsfilerna med hjälp av JSON-konfigurationsprovidern. Lägg till följande i appinställningsfilen:

"DistributedTokenCache": {
  "DisableL1Cache": false,
  "L1CacheSizeLimit": 524288000,
  "Encrypt": true,
  "SlidingExpirationInHours": 1
},
"DataProtection": {
  "BlobUri": "{BLOB URI}",
  "KeyIdentifier": "{KEY IDENTIFIER}"
}

Exempelavsnitt DataProtection :

"DataProtection": {
  "BlobUri": "https://contoso.blob.core.windows.net/data-protection/keys.xml",
  "KeyIdentifier": "https://contoso.vault.azure.net/keys/data-protection"
}

Gör följande ändringar i Program filen:

builder.Services.Configure<MsalDistributedTokenCacheAdapterOptions>(
    options =>
    {
+       var config = builder.Configuration.GetSection("DistributedTokenCache");

-       options.DisableL1Cache = false;
+       options.DisableL1Cache = config.GetValue<bool>("DisableL1Cache");

-       options.L1CacheOptions.SizeLimit = 500 * 1024 * 1024;
+       options.L1CacheOptions.SizeLimit = config.GetValue<long>("L1CacheSizeLimit");

-       options.Encrypt = true;
+       options.Encrypt = config.GetValue<bool>("Encrypt");

-       options.SlidingExpiration = TimeSpan.FromHours(1);
+       options.SlidingExpiration = 
+           TimeSpan.FromHours(config.GetValue<int>("SlidingExpirationInHours"));
    });

- builder.Services.AddDataProtection()
-     .SetApplicationName("BlazorWebAppEntra")
-     .PersistKeysToAzureBlobStorage(new Uri("{BLOB URI}"), credential)
-     .ProtectKeysWithAzureKeyVault(new Uri("{KEY IDENTIFIER}"), credential);

Lägg till följande kod där tjänster konfigureras i Program filen:

var config = builder.Configuration.GetSection("DataProtection");

builder.Services.AddDataProtection()
    .SetApplicationName("BlazorWebAppEntra")
    .PersistKeysToAzureBlobStorage(
        new Uri(config.GetValue<string>("BlobUri") ??
        throw new Exception("Missing Blob URI")),
        credential)
    .ProtectKeysWithAzureKeyVault(
        new Uri(config.GetValue<string>("KeyIdentifier") ?? 
        throw new Exception("Missing Key Identifier")), 
        credential);

Mer information om hur du använder en delad dataskyddsnyckelring och nyckellagringsproviders finns i följande resurser:

• Nyckellagringsproviders i ASP.NET Core
• Konfigurera ASP.NET Core Data Protection
• Använda Azure SDK för .NET i ASP.NET Core-appar
• Värd ASP.NET Core i en webbgrupp: Dataskydd
• Konfigurera ASP.NET Core Data Protection
• Nyckellagringsproviders i ASP.NET Core
• Dokumentation om Azure Key Vault
• Dokumentation om Azure Storage
• Ge åtkomst till Key Vault-nycklar, certifikat och hemligheter med rollbaserad åtkomstkontroll i Azure

YARP-vidarebefordrarens målprefix

Serverprojektets Blazor Web App YARP-vidarebefordrare, där användarens åtkomsttoken är kopplad till webb-API-anropet MinimalApiJwt , anger målprefixet https://weatherapi. Det här värdet matchar projektnamnet som skickas till AddProject i Program projektets Aspire.AppHost fil.

Vidarebefordrare i Blazor Web App serverprojektet (BlazorWebAppEntra):

app.MapForwarder("/weather-forecast", "https://weatherapi", transformBuilder =>
{
    ...
}).RequireAuthorization();

Matchande projektnamn i filen för Program Aspire App Host-projektet (Aspire.AppHost):

var weatherApi = builder.AddProject<Projects.MinimalApiJwt>("weatherapi");

Du behöver inte ändra målprefixet för YARP-vidarebefordraren när du distribuerar Blazor Web App till produktion. Microsoft Identity Web Downstream API-paketet använder bas-URI:n som skickas via konfigurationen för att göra webb-API-anropet från ServerWeatherForecaster, inte från målprefixet för YARP-vidarebefordraren. I produktion transformerar YARP-vidarebefordraren bara begäran och lägger till användarens åtkomsttoken.

Omdirigera till startsidan vid utloggning

Komponenten LogInOrOut (Layout/LogInOrOut.razor) anger ett dolt fält för retur-URL:en (ReturnUrl) till den aktuella URL:en (currentURL). När användaren loggar ut från appen returnerar identitetsprovidern användaren till sidan som de loggade ut från. Om användaren loggar ut från en säker sida returneras de till samma säkra sida och skickas tillbaka via autentiseringsprocessen. Det här autentiseringsflödet är rimligt när användarna behöver ändra konton regelbundet.

Du kan också använda följande LogInOrOut komponent, som inte anger någon retur-URL när du loggar ut.

Layout/LogInOrOut.razor:

<div class="nav-item px-3">
    <AuthorizeView>
        <Authorized>
            <form action="authentication/logout" method="post">
                <AntiforgeryToken />
                <button type="submit" class="nav-link">
                    <span class="bi bi-arrow-bar-left-nav-menu" aria-hidden="true">
                    </span> Logout
                </button>
            </form>
        </Authorized>
        <NotAuthorized>
            <a class="nav-link" href="authentication/login">
                <span class="bi bi-person-badge-nav-menu" aria-hidden="true"></span>
                Login
            </a>
        </NotAuthorized>
    </AuthorizeView>
</div>

Väderdatasäkerhet

Mer information om hur den här appen säkrar sina väderdata finns i Säkra data i Blazor Web Apps med interaktiv automatisk återgivning.

Felsöka

Skogsavverkning

Serverappen är en standardapp för ASP.NET Core. Se vägledningen för ASP.NET Core-loggning för att aktivera en lägre loggningsnivå i serverappen.

Information om hur du aktiverar felsökning eller spårningsloggning för Blazor WebAssembly autentisering finns i avsnittet autentiseringsloggning på klientsidani ASP.NET Core-loggning Blazor med artikelversionsväljaren inställd på ASP.NET Core i .NET 7 eller senare.

Vanliga fel

• Debuggern avbryter på ett undantag under utloggning med Microsoft Entra External ID

  Följande undantag stoppar Visual Studio-felsökningsprogrammet vid utloggning med Microsoft Entra Externt ID:

  Uncaught TypeError TypeError: Failed to execute 'postMessage' on 'Window': The provided value cannot be converted to a sequence.

  

  Undantaget genereras från Entra JavaScript-kod, så det här är inget problem med ASP.NET Core. Undantaget påverkar inte appfunktionerna i produktion, så undantaget kan ignoreras vid testning av lokal utveckling.

• Felkonfiguration av appen eller Identity IP-leverantör

  De vanligaste felen orsakas av felaktig konfiguration. Följande är några exempel:

  • Beroende på kraven i scenariot förhindrar en saknad eller felaktig utfärdare, instans, klient-ID, klientdomän, klient-ID eller omdirigerings-URI en app från att autentisera klienter.
  • Felaktiga omfång för begäran hindrar klienter från att komma åt serverwebb-API-slutpunkter.
  • Felaktiga eller saknade server-API-behörigheter hindrar klienter från att komma åt serverwebb-API-slutpunkter.
  • Köra appen på en annan port än vad som har konfigurerats i omdirigerings-URI:n för IP-adressens appregistrering. Observera att en port inte krävs för Microsoft Entra-ID och en app som körs på en localhost utvecklingstestningsadress, men appens portkonfiguration och porten där appen körs måste matcha för icke-localhost adresser.

  Konfigurationsomfattningen i den här artikeln visar exempel på korrekt konfiguration. Kontrollera noggrant konfigurationen för att leta efter fel i appar och IP-adresser.

  Om konfigurationen verkar vara korrekt:

  • Analysera applikationsloggar.

  • Granska nätverkstrafiken mellan klientappen och IP- eller serverappen med webbläsarens utvecklarverktyg. Ofta returneras ett exakt felmeddelande eller ett meddelande med en ledtråd till vad som orsakar problemet till klienten av IP- eller serverappen efter en begäran. Vägledning för utvecklarverktyg finns i följande artiklar:

    • Google Chrome (Google-dokumentation)
    • Microsoft Edge
    • Mozilla Firefox (Mozilla-dokumentation)

  Dokumentationsteamet svarar på dokumentationsfeedback och buggar i artiklar. Starta ett ärende från Den här sidan feedbacksektionen, men de kan inte tillhandahålla produktsupport. Det finns flera offentliga supportforum som hjälper dig att felsöka en app. Vi rekommenderar följande:

  • Stack Overflow (tagg: blazor)
  • ASP.NET Core Slack Team
  • Blazor Gitter

  Föregående forum ägs eller kontrolleras inte av Microsoft.

  För rapporter om icke-säkerhetsrelaterade, icke-känsliga och icke-konfidentiella reproducerbara ramverksfel, skapa ett ärende med ASP.NET Core-produktenheten. Öppna inte ett ärende med produktgruppen förrän du noggrant har undersökt orsaken till ett problem och inte kan lösa det själv och med hjälp av communityt på ett offentligt support-forum. Produktenheten kan inte felsöka enskilda appar som har brutits på grund av enkel felkonfiguration eller användningsfall som rör tjänster från tredje part. Om en rapport är känslig eller konfidentiell eller beskriver en potentiell säkerhetsbrist i produkten som cyberattacker kan utnyttja kan du läsa Rapportering av säkerhetsproblem och buggar (dotnet/aspnetcore GitHub-lagringsplats).

• Obehörig klient för ME-ID

  info: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2] Auktoriseringen misslyckades. Dessa krav uppfylldes inte: DenyAnonymousAuthorizationRequirement: Kräver en autentiserad användare.

  Återanropsfel vid inloggning från ME-ID:

  • Fel: unauthorized_client
  • Beskrivning: AADB2C90058: The provided application is not configured to allow public clients.

  Så här löser du felet:

  1. Gå till -appens manifest i Azure-portalen.
  2. Ange attributet allowPublicClient till null eller true.

Cookies och webbplatsdata

Cookies och webbplatsdata kan sparas mellan appuppdateringar och störa testning och felsökning. Rensa följande när du gör ändringar i appkoden, ändringar av användarkonton med providern eller konfigurationsändringar för providerappen:

• Cookies för användarinloggning
• App-cookies
• Cachelagrade och lagrade webbplatsdata

En metod för att förhindra kvardröjande cookies och webbplatsdata från att störa testning och felsökning är att:

• Konfigurera en webbläsare
  • Använd en webbläsare för testning som du kan konfigurera för att ta bort alla cookie och platsdata varje gång webbläsaren stängs.
  • Kontrollera att webbläsaren stängs manuellt eller av IDE för ändringar i appen, testanvändaren eller providerkonfigurationen.
• Använd ett anpassat kommando för att öppna en webbläsare i InPrivate- eller Incognito-läge i Visual Studio:
  • Öppna dialogrutan Bläddra med från Visual Studio-knappen Kör.
  • Välj knappen Lägg till.
  • Ange sökvägen till webbläsaren i fältet Program. Följande körbara filvägar är typiska installationsplatser för Windows 10. Om webbläsaren är installerad på en annan plats eller om du inte använder Windows 10 anger du sökvägen till webbläsarens körbara fil.
    • Microsoft Edge: C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
    • Google Chrome: C:\Program Files (x86)\Google\Chrome\Application\chrome.exe
    • Mozilla Firefox: C:\Program Files\Mozilla Firefox\firefox.exe
  • I fältet Argument anger du det kommandoradsalternativ som webbläsaren använder för att öppna i InPrivate- eller Inkognitoläge. Vissa webbläsare kräver appens URL.
    • Microsoft Edge: Använd -inprivate.
    • Google Chrome: Använd --incognito --new-window {URL}, där platshållaren för {URL} är url:en som ska öppnas (till exempel https://localhost:5001).
    • Mozilla Firefox: Använd -private -url {URL}, där platshållaren {URL} är url:en som ska öppnas (till exempel https://localhost:5001).
  • Ange ett namn i fältet Användarvänligt namn. Till exempel Firefox Auth Testing.
  • Välj knappen OK.
  • Om du vill undvika att behöva välja webbläsarprofilen för varje iteration av testning med en app anger du profilen som standard med knappen Ange som standard.
  • Kontrollera att webbläsaren är stängd av IDE för alla ändringar i appen, testanvändaren eller providerkonfigurationen.

Appuppgraderingar

En fungerande app kan misslyckas omedelbart efter att ha uppgraderat .NET Core SDK på utvecklingsdatorn eller ändrat paketversioner i appen. I vissa fall kan osammanhängande paket orsaka att en app slutar fungera vid genomförande av större uppgraderingar. De flesta av dessa problem kan åtgärdas genom att följa dessa instruktioner:

1. Rensa det lokala systemets NuGet-paketcacheminnen genom att köra dotnet nuget locals all --clear från ett kommandogränssnitt.
2. Ta bort projektets mappar bin och obj.
3. Återställa och återskapa projektet.
4. Ta bort alla filer i distributionsmappen på servern innan du distribuerar om appen.

Starta lösningen från rätt projekt

Blazor Web Apps:

• För ett av BFF-mönsterexemplen (Backend-for-Frontend) startar du lösningen från Aspire/Aspire.AppHost projektet.
• Starta lösningen från serverprojektet för ett av de icke-BFF-mönsterexemplen.

Blazor Server:

Starta lösningen från serverprojektet.

Inspektera användaren

Följande UserClaims komponent kan användas direkt i appar eller fungera som grund för ytterligare anpassning.

UserClaims.razor:

@page "/user-claims"
@using System.Security.Claims
@using Microsoft.AspNetCore.Authorization
@attribute [Authorize]

<PageTitle>User Claims</PageTitle>

<h1>User Claims</h1>

@if (claims.Any())
{
    <ul>
        @foreach (var claim in claims)
        {
            <li><b>@claim.Type:</b> @claim.Value</li>
        }
    </ul>
}

@code {
    private IEnumerable<Claim> claims = Enumerable.Empty<Claim>();

    [CascadingParameter]
    private Task<AuthenticationState>? AuthState { get; set; }

    protected override async Task OnInitializedAsync()
    {
        if (AuthState == null)
        {
            return;
        }

        var authState = await AuthState;
        claims = authState.User.Claims;
    }
}

Ytterligare resurser

• Anropa ett webb-API från en ASP.NET Core-app Blazor : Microsofts identitetsplattform för webb-API-anrop
• dokumentation om Microsofts identitetsplattform
• Dokumentation om webb-API | Microsofts identitetsplattform
• Ett webb-API som anropar webb-API:er: Anropa ett API: Alternativ 2: Anropa ett underordnat webb-API med hjälpklassen
• AzureAD/microsoft-identity-web GitHub-lagringsplats: Användbar vägledning för att implementera Microsoft Identity Web for Microsoft Entra ID och Azure Active Directory B2C för ASP.NET Core-appar, inklusive länkar till exempelappar och relaterad Azure-dokumentation. För närvarande hanteras inte Blazor Web Apputtryckligen av Azure-dokumentationen, men konfigurationen av en Blazor Web App för ME-ID och värd i Azure är densamma som för vilken ASP.NET Core-webbapp som helst.
• AuthenticationStateProvider tjänst
• Hantera autentiseringstillstånd i Blazor Web Apps
• Service-abstraktioner i Blazor Web Apps