Aplikacja internetowa, która loguje użytkowników: konfiguracja kodu

Fragmenty kodu w tym artykule i następujące elementy są wyodrębniane z samouczka przyrostowego aplikacji internetowej platformy ASP.NET Core, rozdział 1.

Aby uzyskać szczegółowe informacje o implementacji, warto zapoznać się z tym samouczkiem.

Fragmenty kodu w tym artykule i następujące elementy są wyodrębniane z przykładu aplikacji internetowej ASP.NET.

Aby uzyskać szczegółowe informacje o implementacji, warto zapoznać się z tym przykładem.

Fragmenty kodu w tym artykule i poniżej zostały wyodrębnione z aplikacji internetowej Java wywołującej przykład microsoft graph w języku MSAL w języku Java.

Aby uzyskać szczegółowe informacje o implementacji, warto zapoznać się z tym przykładem.

Fragmenty kodu w tym artykule i poniższe informacje są wyodrębniane z aplikacji internetowej Node.js podpisywania użytkowników w przykładzie w środowisku MSAL Node.

Aby uzyskać szczegółowe informacje o implementacji, warto zapoznać się z tym przykładem.

Fragmenty kodu w tym artykule i następujące elementy są wyodrębniane z aplikacji internetowej w języku Python wywołującej przykład microsoft graph przy użyciu pakietu tożsamości (otoka dotycząca biblioteki MSAL Python).

Aby uzyskać szczegółowe informacje o implementacji, warto zapoznać się z tym przykładem.

W ASP.NET Core te ustawienia znajdują się w pliku appsettings.json w sekcji "Microsoft Entra ID".

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "[Enter the tenantId here]",

    // Client ID (application ID) obtained from the Azure portal
    "ClientId": "[Enter the Client Id here]",
    "CallbackPath": "/signin-oidc",
    "SignedOutCallbackPath": "/signout-oidc"
  }
}

W programie ASP.NET Core inny plik (properties\launchSettings.json) zawiera adres URL (applicationUrl) i port TLS/SSL (sslPort) dla aplikacji i różnych profilów.

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:3110/",
      "sslPort": 44321
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "webApp": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "http://localhost:3110/"
    }
  }
}

W witrynie Azure Portal identyfikatory URI przekierowania zarejestrowane na stronie Uwierzytelnianie aplikacji muszą być zgodne z tymi adresami URL. W przypadku dwóch poprzednich plików konfiguracji będzie https://localhost:44321/signin-oidcto . Przyczyną jest to , applicationUrl http://localhost:3110ale sslPort jest określony (44321). CallbackPath to /signin-oidc, zgodnie z definicją w pliku appsettings.json.

W ten sam sposób identyfikator URI wylogowania zostanie ustawiony na https://localhost:44321/signout-oidcwartość .

W ASP.NET aplikacja jest konfigurowana za pomocą pliku appsettings.json , wiersze od 12 do 15.

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "[Enter the tenantId here]",
    "ClientId": "[Enter the Client Id here]",
  }
}

W witrynie Azure Portal identyfikatory URI odpowiedzi zarejestrowane na stronie Uwierzytelnianie aplikacji muszą być zgodne z tymi adresami URL. Oznacza to, że powinny być https://localhost:44326/.

W języku Java konfiguracja znajduje się w pliku application.properties znajdującym się w lokalizacji src/main/resources.

aad.clientId=Enter_the_Application_Id_here
aad.authority=https://login.microsoftonline.com/Enter_the_Tenant_Info_Here/
aad.secretKey=Enter_the_Client_Secret_Here
aad.redirectUriSignin=http://localhost:8080/msal4jsample/secure/aad
aad.redirectUriGraph=http://localhost:8080/msal4jsample/graph/me

W witrynie Azure Portal identyfikatory URI odpowiedzi zarejestrowane na stronie Uwierzytelnianie aplikacji muszą być zgodne z redirectUri wystąpieniami definiowanymi przez aplikację. Oznacza to, że powinny być http://localhost:8080/msal4jsample/secure/aad i http://localhost:8080/msal4jsample/graph/me.

W tym miejscu parametry konfiguracji znajdują się w pliku .env.dev jako zmienne środowiskowe:

CLOUD_INSTANCE="Enter_the_Cloud_Instance_Id_Here" # cloud instance string should end with a trailing slash
TENANT_ID="Enter_the_Tenant_Info_Here"
CLIENT_ID="Enter_the_Application_Id_Here"
CLIENT_SECRET="Enter_the_Client_Secret_Here"

REDIRECT_URI="http://localhost:3000/auth/redirect"
POST_LOGOUT_REDIRECT_URI="http://localhost:3000"

GRAPH_API_ENDPOINT="Enter_the_Graph_Endpoint_Here" # graph api endpoint string should end with a trailing slash

EXPRESS_SESSION_SECRET="Enter_the_Express_Session_Secret_Here"

Te parametry służą do tworzenia obiektu konfiguracji w pliku authConfig.js , który ostatecznie zostanie użyty do zainicjowania węzła MSAL:

/*
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

require('dotenv').config({ path: '.env.dev' });

/**
 * Configuration object to be passed to MSAL instance on creation.
 * For a full list of MSAL Node configuration parameters, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/configuration.md
 */
const msalConfig = {
    auth: {
        clientId: process.env.CLIENT_ID, // 'Application (client) ID' of app registration in Azure portal - this value is a GUID
        authority: process.env.CLOUD_INSTANCE + process.env.TENANT_ID, // Full directory URL, in the form of https://login.microsoftonline.com/<tenant>
        clientSecret: process.env.CLIENT_SECRET // Client secret generated from the app registration in Azure portal
    },
    system: {
        loggerOptions: {
            loggerCallback(loglevel, message, containsPii) {
                console.log(message);
            },
            piiLoggingEnabled: false,
            logLevel: 3,
        }
    }
}

const REDIRECT_URI = process.env.REDIRECT_URI;
const POST_LOGOUT_REDIRECT_URI = process.env.POST_LOGOUT_REDIRECT_URI;
const GRAPH_ME_ENDPOINT = process.env.GRAPH_API_ENDPOINT + "v1.0/me";

module.exports = {
    msalConfig,
    REDIRECT_URI,
    POST_LOGOUT_REDIRECT_URI,
    GRAPH_ME_ENDPOINT
};

W witrynie Azure Portal identyfikatory URI odpowiedzi zarejestrowane na stronie Uwierzytelnianie aplikacji muszą być zgodne z wystąpieniami identyfikatora redirectUri definiowanymi przez aplikację (http://localhost:3000/auth/redirect).

Dla uproszczenia w tym artykule wpis tajny klienta jest przechowywany w pliku konfiguracji. W aplikacji produkcyjnej rozważ użycie magazynu kluczy lub zmiennej środowiskowej. Jeszcze lepszym rozwiązaniem jest użycie certyfikatu.

Parametry konfiguracji są ustawiane w pliku env jako zmienne środowiskowe:

# Note: If you are using Azure App Service, go to your app's Configuration,
# and then set the following values into your app's "Application settings".

CLIENT_ID=<client id>
CLIENT_SECRET=<client secret>

# Expects a full authority URL such as "https://login.microsoftonline.com/TENANT_GUID"
# or "https://login.microsoftonline.com/contoso.onmicrosoft.com".
# Alternatively, leave it undefined if you are building a multi-tenant app in world-wide cloud
#AUTHORITY=<authority url>

Do tych zmiennych środowiskowych odwołuje się app_config.py:

import os

# Application (client) ID of app registration
CLIENT_ID = os.getenv("CLIENT_ID")
# Application's generated client secret: never check this into source control!
CLIENT_SECRET = os.getenv("CLIENT_SECRET")

# You can configure your authority via environment variable
# Defaults to a multi-tenant app in world-wide cloud
AUTHORITY = os.getenv("AUTHORITY", "https://login.microsoftonline.com/common")

REDIRECT_PATH = "/getAToken"  # Used for forming an absolute URL to your redirect URI.
# The absolute URL must match the redirect URI you set
# in the app's registration in the Azure portal.

# You can find more Microsoft Graph API endpoints from Graph Explorer
# https://developer.microsoft.com/en-us/graph/graph-explorer
ENDPOINT = 'https://graph.microsoft.com/v1.0/users'  # This resource requires no admin consent

# You can find the proper permission names from this document
# https://docs.microsoft.com/en-us/graph/permissions-reference
SCOPE = ["User.ReadBasic.All"]

# Tells the Flask-session extension to store sessions in the filesystem
SESSION_TYPE = "filesystem"
# Using the file system will not work in most production systems,
# it's better to use a database-backed session store instead.

Plik env nigdy nie powinien być zaewidencjonowany w kontroli źródła, ponieważ zawiera wpisy tajne. Przykładowy przewodnik Szybki start zawiera plik .gitignore , który uniemożliwia zaewidencjonowanie pliku env .

# Environments
.env

W aplikacjach internetowych platformy ASP.NET Core (i internetowych interfejsach API) aplikacja jest chroniona, ponieważ masz Authorize atrybut na kontrolerach lub akcjach kontrolera. Ten atrybut sprawdza, czy użytkownik jest uwierzytelniony. Przed wydaniem platformy .NET 6 inicjowanie kodu znajdowało się w pliku Startup.cs . Nowe projekty ASP.NET Core z platformą .NET 6 nie zawierają już pliku Startup.cs . Jego miejscem jest plik Program.cs . Pozostała część tego samouczka dotyczy platformy .NET 5 lub starszej wersji.

 services.AddAuthentication(AzureADDefaults.AuthenticationScheme)
         .AddAzureAD(options => Configuration.Bind("AzureAd", options));

1. Dodaj pakiety NuGet Microsoft.Identity.Web i Microsoft.Identity.Web.UI do projektu. Usuń pakiet NuGet, Microsoft.AspNetCore.Authentication.AzureAD.UI jeśli jest obecny.

2. Zaktualizuj kod w pliku , ConfigureServices aby używał AddMicrosoftIdentityWebApp metod i AddMicrosoftIdentityUI .

   public class Startup
   {
    ...
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
     services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
            .AddMicrosoftIdentityWebApp(Configuration, "AzureAd");
   
     services.AddRazorPages().AddMvcOptions(options =>
     {
      var policy = new AuthorizationPolicyBuilder()
                    .RequireAuthenticatedUser()
                    .Build();
      options.Filters.Add(new AuthorizeFilter(policy));
     }).AddMicrosoftIdentityUI();
   

3. W metodzie Configure w Startup.cs włącz uwierzytelnianie za pomocą wywołania metody app.UseAuthentication(); i app.MapControllers();.

   // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
   public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
   {
    // more code here
    app.UseAuthentication();
    app.UseAuthorization();
   
    app.MapRazorPages();
    app.MapControllers();
    // more code here
   }
   

W tym kodzie:

• Metoda rozszerzenia jest zdefiniowana AddMicrosoftIdentityWebApp w pliku Microsoft.Identity.Web, który;

  • Konfiguruje opcje odczytu pliku konfiguracji (tutaj w sekcji "Microsoft Entra ID")
  • Konfiguruje opcje OpenID Connect tak, aby urząd był Platforma tożsamości Microsoft.
  • Weryfikuje wystawcę tokenu.
  • Gwarantuje, że oświadczenia odpowiadające nazwie są mapowane z preferred_username oświadczenia w tokenie identyfikatora.

• Oprócz obiektu konfiguracji można określić nazwę sekcji konfiguracji podczas wywoływania metody AddMicrosoftIdentityWebApp. Domyślnie jest AzureAdto .

• AddMicrosoftIdentityWebApp ma inne parametry dla zaawansowanych scenariuszy. Na przykład śledzenie zdarzeń oprogramowania pośredniczącego OpenID Connect może pomóc w rozwiązywaniu problemów z aplikacją internetową, jeśli uwierzytelnianie nie działa. Ustawienie opcjonalnego parametru subscribeToOpenIdConnectMiddlewareDiagnosticsEvents true spowoduje wyświetlenie sposobu przetwarzania informacji przez zestaw oprogramowania pośredniczącego ASP.NET Core w miarę postępu odpowiedzi HTTP na tożsamość użytkownika w HttpContext.Userprogramie .

• Metoda rozszerzenia jest definiowana AddMicrosoftIdentityUI w interfejsie użytkownika Microsoft.Identity.Web.UI. Zapewnia on domyślny kontroler do obsługi logowania i wylogowywanie.

Aby uzyskać więcej informacji na temat sposobu tworzenia aplikacji internetowych w witrynie Microsoft.Identity.Web, zobacz Web Apps in microsoft-identity-web (Aplikacje internetowe w witrynie microsoft-identity-web).

Kod związany z uwierzytelnianiem w aplikacji internetowej ASP.NET i internetowych interfejsach API znajduje się w pliku App_Start/Startup.Auth.cs .

 public void ConfigureAuth(IAppBuilder app)
 {
  app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

  app.UseCookieAuthentication(new CookieAuthenticationOptions());

  OwinTokenAcquirerFactory factory = TokenAcquirerFactory.GetDefaultInstance<OwinTokenAcquirerFactory>();
  factory.Build();
  app.AddMicrosoftIdentityWebApi(factory);
 }

W przykładzie języka Java jest używana platforma Spring. Aplikacja jest chroniona, ponieważ implementujesz filtr, który przechwytuje każdą odpowiedź HTTP. W przewodniku Szybki start dla aplikacji internetowych Java ten filtr znajduje się AuthFilter w elem.src/main/java/com/microsoft/azure/msalwebsample/AuthFilter.java

Filtr przetwarza przepływ kodu autoryzacji OAuth 2.0 i sprawdza, czy użytkownik jest uwierzytelniony (isAuthenticated() metoda). Jeśli użytkownik nie jest uwierzytelniony, oblicza adres URL punktów końcowych autoryzacji firmy Microsoft Entra i przekierowuje przeglądarkę do tego identyfikatora URI.

Po nadejściu odpowiedzi zawierającej kod autoryzacji uzyskuje token przy użyciu biblioteki MSAL Java. Po odebraniu tokenu z punktu końcowego tokenu (w identyfikatorze URI przekierowania) użytkownik jest zalogowany.

Aby uzyskać szczegółowe informacje, zobacz metodę doFilter() w AuthFilter.java.

Aby uzyskać szczegółowe informacje na temat przepływu kodu autoryzacji wyzwalanej przez tę metodę, zobacz przepływ kodu autoryzacji Platforma tożsamości Microsoft i OAuth 2.0.

Przykładowy węzeł używa platformy Express. Biblioteka MSAL jest inicjowana w procedurze obsługi tras uwierzytelniania :

var express = require('express');

const authProvider = require('../auth/AuthProvider');
const { REDIRECT_URI, POST_LOGOUT_REDIRECT_URI } = require('../authConfig');

const router = express.Router();

router.get('/signin', authProvider.login({
    scopes: [],
    redirectUri: REDIRECT_URI,
    successRedirect: '/'

Przykład języka Python jest kompilowany przy użyciu platformy Flask, chociaż mogą być również używane inne struktury, takie jak Django. Aplikacja Flask jest inicjowana przy użyciu konfiguracji aplikacji w górnej części app.py:

import identity
import identity.web
import requests
from flask import Flask, redirect, render_template, request, session, url_for
from flask_session import Session

import app_config

app = Flask(__name__)
app.config.from_object(app_config)
Session(app)

Następnie kod tworzy auth obiekt przy użyciu pakietu tożsamości.

auth = identity.web.Auth(
    session=session,
    authority=app.config["AUTHORITY"],
    client_id=app.config["CLIENT_ID"],
    client_credential=app.config["CLIENT_SECRET"],
)