Arbeta med användaridentiteter i Azure App Service-autentisering

Den här artikeln visar hur du arbetar med användaridentiteter när du använder den inbyggda autentiseringen och auktoriseringen i App Service.

Komma åt användaranspråk i appkod

För alla språkramverk gör App Service anspråken i den inkommande token (från en autentiserad slutanvändare eller ett klientprogram) tillgängliga för koden genom att mata in dem i begärandehuvudena. Externa begäranden tillåts inte att ange dessa rubriker, så de finns bara om de anges av App Service. Några exempelrubriker är:

Huvud	Description
X-MS-CLIENT-PRINCIPAL	En Base64-kodad JSON-representation av tillgängliga anspråk. Mer information finns i Avkoda klientens huvudnamn.
X-MS-CLIENT-PRINCIPAL-ID	En identifierare för anroparen som angetts av identitetsprovidern.
X-MS-CLIENT-PRINCIPAL-NAME	Ett läsbart namn för anroparen som angetts av identitetsprovidern, t.ex. Email adress, användarens huvudnamn.
X-MS-CLIENT-PRINCIPAL-IDP	Namnet på identitetsprovidern som används av App Service Authentication.

Providertoken exponeras också via liknande rubriker. Microsoft Identity Provider anger X-MS-TOKEN-AAD-ACCESS-TOKEN till exempel även och X-MS-TOKEN-AAD-ID-TOKEN efter behov.

Anteckning

Olika språkramverk kan presentera dessa rubriker för appkoden i olika format, till exempel gemener eller rubrikfall.

Kod som skrivs på valfritt språk eller ramverk kan hämta den information som behövs från dessa rubriker. Avkodning av klientens huvudnamn omfattar den här processen. För vissa ramverk tillhandahåller plattformen även extra alternativ som kan vara mer praktiska.

Avkodning av klientens huvudnamn

X-MS-CLIENT-PRINCIPAL innehåller den fullständiga uppsättningen tillgängliga anspråk som Base64-kodad JSON. Dessa anspråk genomgår en standardprocess för anspråksmappning, så vissa kan ha andra namn än du skulle se om du bearbetar token direkt. Den avkodade nyttolasten är strukturerad på följande sätt:

{
    "auth_typ": "",
    "claims": [
        {
            "typ": "",
            "val": ""
        }
    ],
    "name_typ": "",
    "role_typ": ""
}

Egenskap	Typ	Description
auth_typ	sträng	Namnet på identitetsprovidern som används av App Service Authentication.
claims	en matris med objekt	En matris med objekt som representerar tillgängliga anspråk. Varje objekt innehåller typ och val egenskaper.
typ	sträng	Namnet på anspråket. Detta kan ha varit föremål för standardanspråkmappning och kan skilja sig från motsvarande anspråk som finns i en token.
val	sträng	Anspråkets värde.
name_typ	sträng	Namnanspråkstypen, som vanligtvis är en URI som tillhandahåller schemainformation om anspråket name om en definieras.
role_typ	sträng	Rollanspråkstypen, som vanligtvis är en URI som tillhandahåller schemainformation om anspråket role om en definieras.

För att bearbeta det här huvudet måste din app avkoda nyttolasten och iterera genom matrisen claims för att hitta anspråk av intresse. Det kan vara praktiskt att konvertera dessa till en representation som används av appens språkramverk. Här är ett exempel på den här processen i C# som konstruerar en ClaimsPrincipal-typ som appen ska använda:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.AspNetCore.Http;

public static class ClaimsPrincipalParser
{
    private class ClientPrincipalClaim
    {
        [JsonPropertyName("typ")]
        public string Type { get; set; }
        [JsonPropertyName("val")]
        public string Value { get; set; }
    }

    private class ClientPrincipal
    {
        [JsonPropertyName("auth_typ")]
        public string IdentityProvider { get; set; }
        [JsonPropertyName("name_typ")]
        public string NameClaimType { get; set; }
        [JsonPropertyName("role_typ")]
        public string RoleClaimType { get; set; }
        [JsonPropertyName("claims")]
        public IEnumerable<ClientPrincipalClaim> Claims { get; set; }
    }

    public static ClaimsPrincipal Parse(HttpRequest req)
    {
        var principal = new ClientPrincipal();

        if (req.Headers.TryGetValue("x-ms-client-principal", out var header))
        {
            var data = header[0];
            var decoded = Convert.FromBase64String(data);
            var json = Encoding.UTF8.GetString(decoded);
            principal = JsonSerializer.Deserialize<ClientPrincipal>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }

        /** 
         *  At this point, the code can iterate through `principal.Claims` to
         *  check claims as part of validation. Alternatively, we can convert
         *  it into a standard object with which to perform those checks later
         *  in the request pipeline. That object can also be leveraged for 
         *  associating user data, etc. The rest of this function performs such
         *  a conversion to create a `ClaimsPrincipal` as might be used in 
         *  other .NET code.
         */

        var identity = new ClaimsIdentity(principal.IdentityProvider, principal.NameClaimType, principal.RoleClaimType);
        identity.AddClaims(principal.Claims.Select(c => new Claim(c.Type, c.Value)));
        
        return new ClaimsPrincipal(identity);
    }
}

Ramverksspecifika alternativ

För ASP.NET 4.6-appar fyller App Service ClaimsPrincipal.Current med den autentiserade användarens anspråk, så att du kan följa standardkodmönstret för .NET, inklusive [Authorize] attributet. På samma sätt fyller App Service variabeln _SERVER['REMOTE_USER'] för PHP-appar. För Java-appar är anspråken tillgängliga från Tomcat-servleten.

För Azure FunctionsClaimsPrincipal.Current fylls inte i för .NET-kod, men du kan fortfarande hitta användaranspråken i begärandehuvudena ClaimsPrincipal eller hämta objektet från begärandekontexten eller till och med via en bindningsparameter. Mer information finns i Arbeta med klientidentiteter i Azure Functions.

För .NET Core har Microsoft.Identity.Web stöd för att fylla den aktuella användaren med App Service autentisering. Om du vill veta mer kan du läsa om det på Wikin Microsoft.Identity.Web eller se den som visas i den här självstudien för en webbapp som har åtkomst till Microsoft Graph.

Anteckning

För att anspråksmappning ska fungera måste du aktivera tokenarkivet.

Komma åt användaranspråk med hjälp av API:et

Om tokenarkivet är aktiverat för din app kan du även hämta annan information om den autentiserade användaren genom att anropa /.auth/me.

Nästa steg

Självstudie: Autentisera och auktorisera användare från slutpunkt till slutpunkt