Webbapp som loggar in användare: Kodkonfiguration

Välj webbplattformstyp och använd följande URI:er för din ASP.NET Core-webbapp

• Omdirigerings-URI : https://localhost:44321/signin-oidc
• Url för utloggning i frontkanalen : https://localhost:44321/signout-oidc

Välj typ av webbplattform och använd följande URI:er för din ASP.NET webbapp

• Omdirigerings-URI : https://localhost:44326/

• Välj typ av webbplattform och använd följande URI:er som används i exempelappen:

  • http://localhost:8080/msal4jsample/secure/aad
  • http://localhost:8080/msal4jsample/graph/me

• Lägg till en klienthemlighet i ditt program. Mer information finns i Lägg till en autentiseringsuppgift i ditt program . Registrera värdet för klienthemlighet för senare användning.

• Välj typ av webbplattform och använd följande URI

  • Omdirigerings-URI : http://localhost:3000/auth/redirect

• Lägg till en klienthemlighet i ditt program. Mer information finns i Lägg till en autentiseringsuppgift i ditt program . Registrera värdet för klienthemlighet för senare användning.

• Välj typ av webbplattform och använd följande URI

  • Omdirigerings-URI : http://localhost:5000/getAToken

• Lägg till en klienthemlighet i ditt program. Mer information finns i Lägg till en autentiseringsuppgift i ditt program . Registrera värdet för klienthemlighet för senare användning.

Kodfragmenten i den här artikeln och de följande har extraherats från ASP.NET Core-webbappens inkrementella självstudie, kapitel 1.

Du kanske vill se den här självstudien för fullständig implementeringsinformation.

Kodfragment i den här artikeln och följande extraheras från ASP.NET webbappexempel.

Du kanske vill se det här exemplet för fullständig implementeringsinformation.

Kodfragment i den här artikeln och följande extraheras från Java-webbprogrammet som anropar Microsoft Graph-exemplet i MSAL Java.

Du kanske vill se det här exemplet för fullständig implementeringsinformation.

Kodfragmenten i den här artikeln och det följande extraheras från Node.js-webbapplikationen för inloggning i MSAL Node-exemplet.

Du kanske vill se det här exemplet för fullständig implementeringsinformation.

Kodfragment i den här artikeln och följande extraheras från Python-webbprogrammet som anropar Microsoft Graph-exemplet med hjälp av identitetspaketet (en omslutning runt MSAL Python).

Du kanske vill se det här exemplet för fullständig implementeringsinformation.

I ASP.NET Core finns de här inställningarna i filen appsettings.json i avsnittet "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"
  }
}

I ASP.NET Core innehåller en annan fil (egenskaper\launchSettings.json) URL:en (applicationUrl) och TLS/SSL-porten (sslPort) för ditt program och olika profiler.

{
  "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/"
    }
  }
}

I Azure Portal måste de omdirigerings-URI:er som du registrerar på sidan Autentisering för ditt program matcha dessa URL:er. För de två föregående konfigurationsfilerna skulle de vara https://localhost:44321/signin-oidc. Orsaken är att applicationUrl är http://localhost:3110, men sslPort anges (44321). CallbackPath är /signin-oidc, enligt definitionen i appsettings.json.

På samma sätt skulle utloggnings-URI:n vara inställd på https://localhost:44321/signout-oidc.

I ASP.NET konfigureras programmet via den appsettings.json filen, raderna 12 till 15.

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

I Azure Portal måste de svars-URI:er som du registrerar på sidan Autentisering för ditt program matcha dessa URL:er. Det vill säga att de borde vara https://localhost:44326/.

I Java finns konfigurationen i filen application.properties under 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

I Azure Portal måste de svars-URI:er som du registrerar på sidan Autentisering för ditt program matcha de redirectUri instanser som programmet definierar. Det vill säga, de borde vara http://localhost:8080/msal4jsample/secure/aad och http://localhost:8080/msal4jsample/graph/me.

Här finns konfigurationsparametrarna i .env.dev som miljövariabler:

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"

Dessa parametrar används för att skapa ett konfigurationsobjekt i authConfig.js fil, som så småningom kommer att användas för att initiera MSAL Node:

/*
 * 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
};

I Azure Portal måste de svars-URI:er som du registrerar på sidan Autentisering för ditt program matcha de redirectUri-instanser som programmet definierar (http://localhost:3000/auth/redirect).

För enkelhetens skull lagras klienthemligheten i konfigurationsfilen. Överväg att använda ett nyckelvalv eller en miljövariabel i produktionsappen. Ett ännu bättre alternativ är att använda ett certifikat.

Konfigurationsparametrarna anges i .env som miljövariabler:

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

Dessa miljövariabler refereras i 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.

. env-filen bör aldrig checkas in i källkontrollen eftersom den innehåller hemligheter. Snabbstartsexemplet innehåller en .gitignore-fil som förhindrar att .env-filen laddas upp.

# Environments
.env

I ASP.NET Core-webbappar (och webb-API:er) skyddas programmet eftersom du har ett Authorize attribut på kontrollanterna eller kontrollantåtgärderna. Det här attributet kontrollerar att användaren är autentiserad. Innan .NET 6 släpptes fanns kodinitiering i filen Startup.cs . Nya ASP.NET Core-projekt med .NET 6 innehåller inte längre en Startup.cs fil. Att ta dess plats är den Program.cs filen. Resten av den här självstudien gäller .NET 5 eller lägre.

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

1. Lägg till NuGet-paketen Microsoft.Identity.Web och Microsoft.Identity.Web.UI i projektet. Microsoft.AspNetCore.Authentication.AzureAD.UI Ta bort NuGet-paketet om det finns.

2. Uppdatera koden i ConfigureServices så att den AddMicrosoftIdentityWebApp använder metoderna och 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. Configure I metoden i Startup.cs aktiverar du autentisering med ett anrop till app.UseAuthentication(); och 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
   }
   

I den koden:

• Tilläggsmetoden AddMicrosoftIdentityWebApp definieras i Microsoft.Identity.Web, som;

  • Konfigurerar alternativ för att läsa konfigurationsfilen (här från avsnittet "Microsoft Entra ID")
  • Konfigurerar OpenID Connect-alternativen så att utfärdaren är Microsofts identitetsplattform.
  • Verifierar utfärdaren av token.
  • Säkerställer att anspråken som motsvarar namnet mappas från anspråket preferred_username i ID-token.

• Förutom konfigurationsobjektet kan du ange namnet på konfigurationsavsnittet när du anropar AddMicrosoftIdentityWebApp. Som standard är AzureAddet .

• AddMicrosoftIdentityWebApp har andra parametrar för avancerade scenarier. Till exempel kan spårning av OpenID Connect-mellanprogramshändelser hjälpa dig att felsöka webbprogrammet om autentiseringen inte fungerar. Om du anger den valfria parametern subscribeToOpenIdConnectMiddlewareDiagnosticsEvents till true visas hur information bearbetas av uppsättningen med ASP.NET Core-mellanprogram när den fortsätter från HTTP-svaret till användarens identitet i HttpContext.User.

• Tilläggsmetoden AddMicrosoftIdentityUI definieras i Microsoft.Identity.Web.UI. Den tillhandahåller en standardstyrenhet för att hantera inloggning och utloggning.

Mer information om hur Microsoft.Identity.Web gör att du kan skapa webbappar finns i Webbappar i microsoft-identity-web.

Koden som är relaterad till autentisering i en ASP.NET webbapp och webb-API:er finns i filen 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);
 }

Java-exemplet använder Spring-ramverket. Programmet skyddas eftersom du implementerar ett filter som fångar upp varje HTTP-svar. I snabbstarten för Java-webbappar finns AuthFilter det här filtret i src/main/java/com/microsoft/azure/msalwebsample/AuthFilter.java.

Filtret bearbetar OAuth 2.0-auktoriseringskodflödet och kontrollerar om användaren är autentiserad (isAuthenticated() -metoden). Om användaren inte autentiseras beräknar den URL:en för Microsoft Entra-auktoriseringsslutpunkterna och omdirigerar webbläsaren till den här URI:n.

När svaret kommer, som innehåller auktoriseringskoden, hämtar det token med hjälp av MSAL Java. När den slutligen tar emot token från tokenslutpunkten (på omdirigerings-URI:n) loggas användaren in.

Mer information finns i doFilter() metoden i AuthFilter.java.

Mer information om det auktoriseringskodflöde som den här metoden utlöser finns i auktoriseringskodflödet Microsofts identitetsplattform och OAuth 2.0.

Node-exemplet använder Express-ramverket. MSAL initieras i autentiseringsvägshanteraren :

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: '/'

Python-exemplet skapas med Flask-ramverket, men även andra ramverk som Django kan användas. Flask-appen initieras med appkonfigurationen överst i 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)

Sedan konstruerar koden ett objekt med hjälp av identitetspaketetauth.

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