Configurer l'authentification unique SAML (SSO) dans une application découplée ASP.NET Core

Marché

Ce guide fournit des étapes détaillées pour configurer l'authentification unique SAML (SSO) dans une application d'architecture découplée ASP.NET Core à l'aide de n'importe quel fournisseur d'identité (IdP) compatible SAML. Le backend (ASP.NET Core) gère l'authentification SSO, génère un jeton JWT et l'expose en toute sécurité à n'importe quel frontend (React, Angular, Vue, etc.).

Pré-requis : Téléchargement Et Installation

• Version .NET 5 et supérieure
• Versions .NET Core 2.1 et .NET Core 3.1

Package NuGet

CLI .NET

PM> NuGet\Install-Package miniOrange.SAML.SSO

> dotnet ajoute le package miniOrange.SAML.SSO

À noter: Pour intégrer le middleware miniOrange ASP.NET SAML SSO dans votre application, vous devrez ajouter les espaces de noms, services et middleware ci-dessous dans votre projet. Vous trouverez ci-dessous un exemple d'implémentation pour référence.

  using miniOrange.saml;
  using System.Reflection;
  var builder=WebApplication.CreateBuilder(args);
  // Add services to the container.
  builder.Services.AddRazorPages();
  builder.Services.AddAuthentication(options =>
  {
    options.DefaultAuthenticationScheme ="SS0_OR_Admin";
    options.DefaultScheme = "SSO_OR_Admin";
    options.DefaultChallengeScheme = "SSO_OR_Admin";
  })
  .AddCookie("moAdmin", options =>
  {
    
  })
  .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
  {
    
  })
  .AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, options =>
  {
    options.TokenValidationParameters = new TokenValidationParameters
    {
      ValidateIssuer = true,
      ValidateAudience = true,
      ValidateLifetime = true,
      ValidateIssuerSigningKey = true,
      ValidIssuer = "your-issuer",
      ValidAudience = "your-audience",
      IssuerSigningKey = new
  SymmetricSecurityKey(Encoding.UTF8.GetBytes("your-secret-key"))
    };
  })
  .AddPolicyScheme("SSO_OR_Admin", "SSO_OR_Admin", options =>
  {
    options.ForwardDefaultSelector = context =>
    {
      // Check if Bearer token exists
      string authHeader = context.Request.Headers["Authorization"].FirstOrDefault() ?? "";
      if (!string.IsNullOrEmpty(authHeader) && authHeader.StartsWith("Bearer"))
      {
        return JwtBearerDefaults.AuthenticationScheme;
      }
      foreach (var cookie in context.Request.Cookies)
      {
         if (cookie.Key.Contains(".AspNetCore.Cookies") &&
        context.Request.Query["ssoaction"] != "config")
        {
          return CookieAuthenticationDefaults.AuthenticationScheme;
        }
    }
    return "moAdmin";
    };
  });
  var app = builder.Build();
  if(!app.Environment.IsDevelopment())
  {
    app.UseExceptionHandler("/Error");
    app.UseHsts();
  }
  app.UseHttpsRedirection();
  app.UseRouting();
  app.UseAuthorization();
  app.MapRazorPages();
  app.UseCookiePolicy();
  app.UseAuthentication();
  app.UseStaticFiles();
  app.UseminiOrangeSAMLSSOMiddleware();
  app.Run();


Package NuGet

CLI .NET

PM> NuGet\Install-Package miniOrange.SAML.SSO

> dotnet ajoute le package miniOrange.SAML.SSO

À noter: Pour intégrer le middleware miniOrange ASP.NET SAML SSO dans votre application, vous devrez ajouter les espaces de noms, services et middleware ci-dessous dans votre projet, ci-dessous voici un exemple.

  using miniOrange.saml;
  using System.Reflection;
  public class Startup
  {
   public Startup(IConfiguration configuration)
   {
    Configuration = configuration;
   }
   public IConfiguration Configuration {get;}
   // This method gets called by the runtime. Use this method to add services to the container.
   public void ConfigureServices(IServiceCollection services)
   {
    services.AddRazorPages();
  services.AddAuthentication(options =>
  {
    options.DefaultAuthenticationScheme ="SS0_OR_Admin";
    options.DefaultScheme = "SSO_OR_Admin";
    options.DefaultChallengeScheme = "SSO_OR_Admin";
  })
  .AddCookie("moAdmin", options =>
  {
    
  })
  .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
  {
    
  })
  .AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, options =>
  {
    options.TokenValidationParameters = new TokenValidationParameters
    {
      ValidateIssuer = true,
      ValidateAudience = true,
      ValidateLifetime = true,
      ValidateIssuerSigningKey = true,
      ValidIssuer = "your-issuer",
      ValidAudience = "your-audience",
      IssuerSigningKey = new
  SymmetricSecurityKey(Encoding.UTF8.GetBytes("your-secret-key"))
    };
  })
  .AddPolicyScheme("SSO_OR_Admin", "SSO_OR_Admin", options =>
  {
    options.ForwardDefaultSelector = context =>
    {
      // Check if Bearer token exists
      string authHeader = context.Request.Headers["Authorization"].FirstOrDefault() ?? "";
      if (!string.IsNullOrEmpty(authHeader) && authHeader.StartsWith("Bearer"))
      {
        return JwtBearerDefaults.AuthenticationScheme;
      }
      foreach (var cookie in context.Request.Cookies)
      {
         if (cookie.Key.Contains(".AspNetCore.Cookies") &&
        context.Request.Query["ssoaction"] != "config")
        {
          return CookieAuthenticationDefaults.AuthenticationScheme;
        }
    }
    return "moAdmin";
    };
  });
   }
   // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
   public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
   {
    if (env.IsDevelopment())
    {
     app.UseDeveloperExceptionPage();
    }
   else
    {
     app.UseExceptionHandler("/Error");
    app.UseHsts();
    }
   app.UseHttpsRedirection();
   app.UseCookiePolicy();
   app.UseAuthentication();
   app.UseStaticFiles();
   app.UseminiOrangeSAMLSSOMiddleware();
   app.UseRouting();
   app.UseAuthorization();
   app.UseEndpoints(endpoints =>
   {
    endpoints.MapRazorPages();
   });
  }
 }


Si vous obtenez le Problèmes CORS lors des appels API, ajoutez le service et la politique ci-dessous.

Étapes de configuration

Guide étape par étape pour ASP.NET Core SAML SSO à l'aide de votre fournisseur d'identité.

2. Configurez votre fournisseur d’identité

• En vertu des Normes sur l’information et les communications, les organismes doivent rendre leurs sites et applications Web accessibles. Ils y parviennent en conformant leurs sites Web au niveau AA des Web Content Accessibility Guidelines (WCAG). Paramètres Plugin onglet, sélectionnez votre fournisseur d'identité dans la liste affichée.

3. Configurer le middleware SAML ASP.NET Core en tant que fournisseur de services

Il existe deux manières détaillées ci-dessous avec lesquelles vous pouvez configurer les métadonnées de votre fournisseur d'identité SAML dans le middleware.

A] Téléchargez les métadonnées à l'aide du bouton Télécharger les métadonnées IDP :

• Si votre fournisseur d'identité vous a fourni l'URL des métadonnées ou le fichier de métadonnées (format .xml uniquement), vous pouvez simplement configurer les métadonnées du fournisseur d'identité dans le middleware à l'aide de Télécharger les métadonnées IDP option.

• Copiez l'URL des métadonnées ou téléchargez le fichier de métadonnées pour le configurer du côté de votre fournisseur d'identité.

• Vous pouvez vous référer à la capture d'écran ci-dessous :

• Vous pouvez choisir l’une des options en fonction du format de métadonnées dont vous disposez.

B] Configurez manuellement les métadonnées du fournisseur d'identité :

• Après avoir configuré votre Fournisseur d'identité, il vous fournira ID d'entité IDP, URL d'authentification unique IDP et Certificat SAML X509 champs respectivement.

• Cliquez à nouveau Enregistrer pour enregistrer vos informations IDP.

4. Test de l'authentification unique SAML

• Cliquez sur le Configuration du test pour tester si la configuration SAML que vous avez effectuée est correcte.

• La capture d'écran ci-dessous montre un résultat réussi. Cliquer sur Intégration SSO pour poursuivre l'intégration SSO.

• Si vous rencontrez une erreur du côté du middleware, une fenêtre similaire à celle ci-dessous s'affichera.

• Pour résoudre l'erreur, vous pouvez suivre les étapes ci-dessous :

• Sous Résolution des problèmes , activez la bascule pour recevoir les journaux du plugin.

• Une fois activé, vous pourrez récupérer les journaux des plugins en naviguant vers Paramètres Plugin onglet et en cliquant sur Configuration du test.

• Téléchargez le fichier journal du Résolution des problèmes onglet pour voir ce qui n'a pas fonctionné.

• Vous pouvez partager le fichier journal avec nous à aspnetsupport@xecurify.com et notre équipe vous contactera pour résoudre votre problème.

5. Cartographie des attributs

• Après avoir testé la configuration, mappez les attributs de votre application avec les attributs du fournisseur d'identité (IdP).

• À noter: Tous les attributs mappés seront stockés dans la session afin que vous puissiez y accéder dans votre application.

6. Code d'intégration

• Ces étapes vous permettent de récupérer les informations utilisateur SSO dans votre application sous la forme de revendications utilisateur.

• À noter: Ce middleware d'essai ne prend en charge que les informations utilisateur dans les revendications, la récupération des informations utilisateur dans la session et les en-têtes est disponible dans le plugin premium

• Créez un point de terminaison GET côté .NET pour renvoyer le jeton JWT après la connexion.
  Remarque : si vous disposez d’une méthode pour créer un JWT, il vous suffit de sélectionner les revendications du cookie .NET.
  Vous trouverez ci-dessous le code pour votre référence :
[HttpGet("gettoken")]
public string GetToken()
{
  if(User.Identity!=null && User.Identity.IsAuthenticated)
  {
    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes
    ("Your-JWT-secret-key"));
    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
    var identity = (ClaimsIdentity)User.Identity;
    var claims = identity.Claims;

    var token = new JwtSecurityToken(
      issuer:"<issuer-name>",
      audience:"<audience>",
      claims:claims,
      expires: DateTime.UtcNow.AddHours(1),
      signingCredentials: creds
      );
      return new JwtSecurityTokenHandler().WriteToken(token);
  }
  return null;
  }


7. Ajouter un bouton de connexion

• Survolez Sélectionner des actions et cliquez sur Copier le lien SSO.

• Utilisez l’URL suivante comme lien dans l’application à partir de laquelle vous souhaitez effectuer l’authentification unique :
https://<application-url>?ssoaction=login&appid=<app-id>

• Après la connexion, vous serez redirigé vers votre application frontale, alors vous devrez faire un appel d'API pour obtenir le jeton et les informations utilisateur.

• Vous trouverez ci-dessous l'exemple de code que vous pouvez utiliser pour effectuer l'appel d'API vers le point de terminaison du jeton pour obtenir le jeton du côté frontend.
fetch("https://<backend-api-baseurl>/api/gettoken", {
  method: "GET",
})
.then((response) => {
  //here you will receive the jwt token and the user details
  console.log(response);
});


8. Intégration des tests

• Démarrez votre application Web API ASP.NET Core

• Démarrez votre application frontend

• Depuis l'application frontale, cliquez sur le Connexion SSO bouton que vous avez ajouté

• Après Connexion SAML, Vous serez redirigé vers votre application front-end. À ce stade, votre application front-end appelle le /api/gettoken point de terminaison, qui renvoie le jeton et les informations de l'utilisateur. Vous pouvez utiliser le Jeton JWT pour effectuer vos autres appels d'API.

Remarque : si vous utilisez l’attribut Authorize sur l’API pour la validation du jeton, vous devrez spécifier la politique d’authentification car nous avons maintenant plusieurs politiques enregistrées.

Pour l'utilisation de JWT : [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]

Articles Relatifs

• SSO ASP.NET SAML
• ASP.NET OAuth SSO
• Authentification à deux facteurs ASP.NET (2FA)

Contactez-nous

Veuillez nous contacter à aspnetsupport@xecurify.comNotre équipe vous accompagnera dans la configuration de l'authentification unique SAML ASP.NET Core. Elle vous aidera à choisir la solution/l'offre la mieux adaptée à vos besoins.