Aggiungere l'accesso a un'app Web .NET MVCAdd sign-in to an .NET MVC web app

Con l'endpoint v2.0 è possibile aggiungere rapidamente l'autenticazione alle app Web con supporto per account Microsoft personali, aziendali o dell'istituto di istruzione.With the v2.0 endpoint, you can quickly add authentication to your web apps with support for both personal Microsoft accounts and work or school accounts. Nelle app Web ASP.NET, a questo scopo si usa il middleware OWIN di Microsoft incluso in .NET Framework 4.5.In ASP.NET web apps, you can accomplish this using Microsoft's OWIN middleware included in .NET Framework 4.5.

Nota

Non tutti gli scenari e le funzionalità di Azure Active Directory sono supportati dall'endpoint 2.0.Not all Azure Active Directory scenarios & features are supported by the v2.0 endpoint. Per determinare se è necessario usare l'endpoint v2.0, leggere le informazioni sulle limitazioni v2.0.To determine if you should use the v2.0 endpoint, read about v2.0 limitations.

Verrà compilata un'applicazione Web che utilizza OWIN per l'accesso dell'utente, la visualizzazione di informazioni sull'utente e la disconnessione dell'utente dall'app.Here we'll build an web app that uses OWIN to sign the user in, display some information about the user, and sign the user out of the app.

DownloadDownload

Il codice per questa esercitazione è salvato su GitHub.The code for this tutorial is maintained on GitHub. Per seguire la procedura è possibile scaricare la struttura dell'app come file con estensione zip o clonare la struttura:To follow along, you can download the app's skeleton as a .zip or clone the skeleton:

git clone --branch skeleton https://github.com/AzureADQuickStarts/AppModelv2-WebApp-OpenIdConnect-DotNet.git

Al termine dell'esercitazione, verrà fornita anche l'app completata.The completed app is provided at the end of this tutorial as well.

Registrare un'appRegister an app

Creare una nuova app in apps.dev.microsoft.com o seguire questa procedura dettagliata.Create a new app at apps.dev.microsoft.com, or follow these detailed steps. Verificare di:Make sure to:

  • Copiare l' ID applicazione assegnato all'app, perché verrà richiesto a breve.Copy down the Application Id assigned to your app, you'll need it soon.
  • Aggiungere la piattaforma Web per l'app.Add the Web platform for your app.
  • Immettere l' URI di reindirizzamentocorretto.Enter the correct Redirect URI. L'URI di reindirizzamento indica ad Azure AD dove indirizzare le risposte di autenticazione. Il valore predefinito per questa esercitazione è https://localhost:44326/.The redirect uri indicates to Azure AD where authentication responses should be directed - the default for this tutorial is https://localhost:44326/.

Installare e configurare l'autenticazione OWINInstall & configure OWIN authentication

In questo caso, verrà configurato il middleware OWIN per l'uso del protocollo di autenticazione OpenID Connect.Here, we'll configure the OWIN middleware to use the OpenID Connect authentication protocol. OWIN verrà usato, tra le altre cose, per inviare le richieste di accesso e disconnessione, gestire la sessione dell'utente e ottenere informazioni sull'utente.OWIN will be used to issue sign-in and sign-out requests, manage the user's session, and get information about the user, amongst other things.

  1. Per iniziare, aprire il file web.config nella radice del progetto e immettere i valori di configurazione dell'app nella sezione <appSettings>.To begin, open the web.config file in the root of the project, and enter your app's configuration values in the <appSettings> section.

    • ida:ClientId rappresenta l' ID applicazione assegnato all'app nel portale di registrazione.The ida:ClientId is the Application Id assigned to your app in the registration portal.
    • ida:RedirectUri rappresenta l' URI di reindirizzamento immesso nel portale.The ida:RedirectUri is the Redirect Uri you entered in the portal.
  2. Successivamente, aggiungere il middleware NuGet al progetto usando la console di Gestione pacchetti.Next, add the OWIN middleware NuGet packages to the project using the Package Manager Console.

     ```
     PM> Install-Package Microsoft.Owin.Security.OpenIdConnect
     PM> Install-Package Microsoft.Owin.Security.Cookies
     PM> Install-Package Microsoft.Owin.Host.SystemWeb
     ```  
    
  3. Aggiungere al progetto una classe OWIN Startup denominata Startup.cs. Fare clic con il pulsante destro del mouse sul progetto, scegliere Aggiungi --> Nuovo elemento e quindi cercare "OWIN".Add an "OWIN Startup Class" to the project called Startup.cs Right click on the project --> Add --> New Item --> Search for "OWIN". Il middleware OWIN richiamerà il metodo Configuration(...) all'avvio dell'app.The OWIN middleware will invoke the Configuration(...) method when your app starts.

  4. Sostituire la dichiarazione della classe con public partial class Startup. Parte di questa classe è già stata implementata in un altro file.Change the class declaration to public partial class Startup - we've already implemented part of this class for you in another file. Nel metodo Configuration(...) eseguire una chiamata a ConfigureAuth(...) per configurare l'autenticazione per l'app Web.In the Configuration(...) method, make a call to ConfigureAuth(...) to set up authentication for your web app

     ```C#
     [assembly: OwinStartup(typeof(Startup))]
    
     namespace TodoList_WebApp
     {
         public partial class Startup
         {
             public void Configuration(IAppBuilder app)
             {
                 ConfigureAuth(app);
             }
         }
     }
     ```
    
  5. Aprire il file App_Start\Startup.Auth.cs e implementare il metodo ConfigureAuth(...).Open the file App_Start\Startup.Auth.cs and implement the ConfigureAuth(...) method. I parametri forniti in OpenIdConnectAuthenticationOptions fungeranno da coordinate per consentire all'app di comunicare con Azure AD.The parameters you provide in OpenIdConnectAuthenticationOptions will serve as coordinates for your app to communicate with Azure AD. È inoltre necessario impostare l'autenticazione tramite cookie: il middleware OpenID Connect usa i cookie in background.You'll also need to set up Cookie Authentication - the OpenID Connect middleware uses cookies underneath the covers.

     ```C#
     public void ConfigureAuth(IAppBuilder app)
                  {
                          app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
    
                          app.UseCookieAuthentication(new CookieAuthenticationOptions());
    
                          app.UseOpenIdConnectAuthentication(
                                  new OpenIdConnectAuthenticationOptions
                                  {
                                          // The `Authority` represents the v2.0 endpoint - https://login.microsoftonline.com/common/v2.0
                                          // The `Scope` describes the permissions that your app will need.  See https://azure.microsoft.com/documentation/articles/active-directory-v2-scopes/
                                          // In a real application you could use issuer validation for additional checks, like making sure the user's organization has signed up for your app, for instance.
    
                                          ClientId = clientId,
                                          Authority = String.Format(CultureInfo.InvariantCulture, aadInstance, "common", "/v2.0"),
                                          RedirectUri = redirectUri,
                                          Scope = "openid email profile",
                                          ResponseType = "id_token",
                                          PostLogoutRedirectUri = redirectUri,
                                          TokenValidationParameters = new TokenValidationParameters
                                          {
                                                  ValidateIssuer = false,
                                          },
                                          Notifications = new OpenIdConnectAuthenticationNotifications
                                          {
                                                  AuthenticationFailed = OnAuthenticationFailed,
                                          }
                                  });
                  }
     ```
    

Invio di richieste di autenticazioneSend authentication requests

L'app ora è configurata correttamente per comunicare con l'endpoint 2.0 mediante il protocollo di autenticazione OpenID Connect.Your app is now properly configured to communicate with the v2.0 endpoint using the OpenID Connect authentication protocol. OWIN ha gestito tutte le difficoltà derivanti dalla creazione dei messaggi di autenticazione, dalla convalida dei token da Azure AD e dalla gestione della sessione utente.OWIN has taken care of all of the ugly details of crafting authentication messages, validating tokens from Azure AD, and maintaining user session. Non resta che dare agli utenti un modo per accedere e disconnettersi.All that remains is to give your users a way to sign in and sign out.

  • È possibile usare tag di autorizzazione nei controller per obbligare l'utente ad accedere prima di aprire una determinata pagina.You can use authorize tags in your controllers to require that user signs in before accessing a certain page. Aprire Controllers\HomeController.cs e aggiungere il tag [Authorize] al controller About.Open Controllers\HomeController.cs, and add the [Authorize] tag to the About controller.

      ```C#
      [Authorize]
      public ActionResult About()
      {
        ...
      ```
    
  • È possibile usare OWIN anche per inviare le richieste di autenticazione direttamente dal codice.You can also use OWIN to directly issue authentication requests from within your code. Aprire Controllers\AccountController.cs.Open Controllers\AccountController.cs. Nelle azioni SignIn() e SignOut() inoltrare rispettivamente le richieste di verifica e di disconnessione di OpenID Connect.In the SignIn() and SignOut() actions, issue OpenID Connect challenge and sign-out requests, respectively.

      ```C#
      public void SignIn()
      {
          // Send an OpenID Connect sign-in request.
          if (!Request.IsAuthenticated)
          {
              HttpContext.GetOwinContext().Authentication.Challenge(new AuthenticationProperties { RedirectUri = "/" }, OpenIdConnectAuthenticationDefaults.AuthenticationType);
          }
      }
    
      // BUGBUG: Ending a session with the v2.0 endpoint is not yet supported.  Here, we just end the session with the web app.  
      public void SignOut()
      {
          // Send an OpenID Connect sign-out request.
          HttpContext.GetOwinContext().Authentication.SignOut(CookieAuthenticationDefaults.AuthenticationType);
          Response.Redirect("/");
      }
      ```
    
  • Ora aprire Views\Shared\_LoginPartial.cshtml,Now, open Views\Shared\_LoginPartial.cshtml. dove si mostreranno all'utente i collegamenti di accesso e disconnessione e si visualizzerà il nome dell'utente.This is where you'll show the user your app's sign-in and sign-out links, and print out the user's name in a view.

      ```HTML
      @if (Request.IsAuthenticated)
      {
          <text>
              <ul class="nav navbar-nav navbar-right">
                  <li class="navbar-text">
    
                      @*The 'preferred_username' claim can be used for showing the user's primary way of identifying themselves.*@
    
                      Hello, @(System.Security.Claims.ClaimsPrincipal.Current.FindFirst("preferred_username").Value)!
                  </li>
                  <li>
                      @Html.ActionLink("Sign out", "SignOut", "Account")
                  </li>
              </ul>
          </text>
      }
      else
      {
          <ul class="nav navbar-nav navbar-right">
              <li>@Html.ActionLink("Sign in", "SignIn", "Account", routeValues: null, htmlAttributes: new { id = "loginLink" })</li>
          </ul>
      }
      ```
    

Visualizzare le informazioni utenteDisplay user information

Quando si autenticano gli utenti con OpenID Connect, l'endpoint v2.0 restituisce un token ID all'app che contiene attestazioni o asserzioni sull'utente.When authenticating users with OpenID Connect, the v2.0 endpoint returns an id_token to the app that contains claims, or assertions about the user. È possibile usare queste attestazioni per personalizzare l'app:You can use these claims to personalize your app:

  • Aprire il file Controllers\HomeController.cs .Open the Controllers\HomeController.cs file. È possibile accedere alle attestazioni dell'utente nei controller tramite l'oggetto di entità di sicurezza ClaimsPrincipal.Current .You can access the user's claims in your controllers via the ClaimsPrincipal.Current security principal object.

      ```C#
      [Authorize]
      public ActionResult About()
      {
          ViewBag.Name = ClaimsPrincipal.Current.FindFirst("name").Value;
    
          // The object ID claim will only be emitted for work or school accounts at this time.
          Claim oid = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier");
          ViewBag.ObjectId = oid == null ? string.Empty : oid.Value;
    
          // The 'preferred_username' claim can be used for showing the user's primary way of identifying themselves
          ViewBag.Username = ClaimsPrincipal.Current.FindFirst("preferred_username").Value;
    
          // The subject or nameidentifier claim can be used to uniquely identify the user
          ViewBag.Subject = ClaimsPrincipal.Current.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value;
    
          return View();
      }
      ```
    

EseguiRun

Infine compilare ed eseguire l'app.Finally, build and run your app! Accedere con un account Microsoft personale, aziendale o dell'istituto di istruzione e osservare come l'identità dell'utente è indicata nella barra di spostamento superiore.Sign in with either a personal Microsoft Account or a work or school account, and notice how the user's identity is reflected in the top navigation bar. È ora disponibile un'app Web protetta usando protocolli standard del settore in grado di autenticare gli utenti con account personali, aziendali e dell'istituto di istruzione.You now have a web app secured using industry standard protocols that can authenticate users with both their personal and work/school accounts.

Come riferimento, l'esempio completato (senza i valori di configurazione) è disponibile in un file con estensione .zip qui. In alternativa, è possibile clonarlo da GitHub:For reference, the completed sample (without your configuration values) is provided as a .zip here, or you can clone it from GitHub:

git clone --branch complete https://github.com/AzureADQuickStarts/AppModelv2-WebApp-OpenIdConnect-DotNet.git

Passaggi successiviNext steps

Ora è possibile passare ad argomenti più avanzati.You can now move onto more advanced topics. È possibile:You may want to try:

Proteggere un'API Web con l'endpoint 2.0 >>Secure a Web API with the the v2.0 endpoint >>

Per altre risorse, vedere:For additional resources, check out:

Ottenere aggiornamenti della sicurezza per i prodottiGet security updates for our products

È consigliabile ricevere notifiche in caso di problemi di sicurezza. A tale scopo, visitare questa pagina e sottoscrivere gli avvisi di sicurezza.We encourage you to get notifications of when security incidents occur by visiting this page and subscribing to Security Advisory Alerts.