Konfigurieren von SAML Single Sign-On (SSO) in einer entkoppelten ASP.NET Core-Anwendung

Übersicht

Dieses Handbuch enthält detaillierte Schritte zum Einrichten von SAML Single Sign-On (SSO) in einer ASP.NET Core-Anwendung mit entkoppelter Architektur unter Verwendung eines beliebigen SAML-kompatiblen Identitätsanbieters (IdP). Das Backend (ASP.NET Core) übernimmt die SSO-Authentifizierung, generiert ein JWT-Token und stellt es sicher jedem Frontend (React, Angular, Vue usw.) zur Verfügung.

Voraussetzungen: Download und Installation

• Version .NET 5 und höher
• Version .NET Core 2.1 und .NET Core 3.1

NuGet-Paket

.NET-CLI

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

> Dotnet-Paket miniOrange.SAML.SSO hinzufügen

Hinweis: Um die miniOrange ASP.NET SAML SSO-Middleware in Ihre Anwendung zu integrieren, müssen Sie die folgenden Namespaces, Dienste und Middleware zu Ihrem Projekt hinzufügen. Unten finden Sie eine Beispielimplementierung als Referenz.

  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();


NuGet-Paket

.NET-CLI

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

> Dotnet-Paket miniOrange.SAML.SSO hinzufügen

Hinweis: Um die miniOrange ASP.NET SAML SSO-Middleware in Ihre Anwendung zu integrieren, müssen Sie die folgenden Namespaces, Dienste und Middleware zu Ihrem Projekt hinzufügen. Unten sehen Sie ein Beispiel.

  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();
   });
  }
 }


Wenn Sie das bekommen CORS-Probleme Fügen Sie beim Tätigen von API-Aufrufen den folgenden Dienst und die folgende Richtlinie hinzu.

Konfigurationsschritte

Schritt-für-Schritt-Anleitung für ASP.NET Core SAML SSO unter Verwendung Ihres Identitätsanbieters.

2. Konfigurieren Sie Ihren Identitätsanbieter

• Unter dem Plugin-Einstellungen Wählen Sie auf der Registerkarte „Identitätsanbieter“ Ihren Identitätsanbieter aus der angezeigten Liste aus.

3. Konfigurieren Sie ASP.NET Core SAML Middleware als Dienstanbieter

Im Folgenden werden zwei Möglichkeiten beschrieben, mit denen Sie die Metadaten Ihres SAML-Identitätsanbieters in der Middleware konfigurieren können.

A] Metadaten über die Schaltfläche „IDP-Metadaten hochladen“ hochladen:

• Wenn Ihr Identitätsanbieter Ihnen die Metadaten-URL oder die Metadatendatei (nur im XML-Format) bereitgestellt hat, können Sie die Metadaten des Identitätsanbieters einfach in der Middleware konfigurieren, indem Sie Folgendes verwenden: Laden Sie IDP-Metadaten hoch .

• Kopieren Sie die Metadaten-URL oder laden Sie die Metadatendatei herunter, um sie auf der Seite Ihres Identitätsanbieters zu konfigurieren.

• Sie können sich auf den Screenshot unten beziehen:

• Sie können eine der Optionen entsprechend dem verfügbaren Metadatenformat auswählen.

B] Konfigurieren Sie die Metadaten des Identitätsanbieters manuell:

• Nach der Konfiguration Ihres Identitätsanbieter, es bietet Ihnen IDP-Entitäts-ID, IDP-Single-Sign-On-URL und SAML X509-Zertifikat Felder bzw.

• Klicke Gespeichert um Ihre IDP-Daten zu speichern.

4. Testen von SAML SSO

• Klicken Sie auf Testkonfiguration Schaltfläche, um zu testen, ob die von Ihnen vorgenommene SAML-Konfiguration korrekt ist.

• Der Screenshot unten zeigt ein erfolgreiches Ergebnis. Klicke auf SSO-Integration um die SSO-Integration weiter fortzusetzen.

• Wenn auf der Middleware-Seite ein Fehler auftritt, wird ein Fenster angezeigt, das dem folgenden ähnelt.

• Um den Fehler zu beheben, können Sie die folgenden Schritte ausführen:

• Der Problembehandlung Aktivieren Sie auf der Registerkarte den Schalter, um die Plugin-Protokolle zu empfangen.

• Sobald diese Option aktiviert ist, können Sie die Plugin-Protokolle abrufen, indem Sie zu Plugin-Einstellungen Tab und klicken Sie auf Testkonfiguration.

• Laden Sie Logdatei von dem Problembehandlung Registerkarte, um zu sehen, was schief gelaufen ist.

• Sie können die teilen Logdatei bei uns bei aspnetsupport@xecurify.com und unser Team wird sich mit Ihnen in Verbindung setzen, um Ihr Problem zu lösen.

5. Attributzuordnung

• Nachdem Sie die Konfiguration getestet haben, ordnen Sie Ihre Anwendungsattribute den Identitätsanbieterattributen (IdP) zu.

• Hinweis: Alle zugeordneten Attribute werden in der Sitzung gespeichert, sodass Sie in Ihrer Anwendung darauf zugreifen können.

6. Integrationscode

• Mit diesen Schritten können Sie die SSO-Benutzerinformationen in Ihrer Anwendung in Form von Benutzeransprüchen abrufen.

• Hinweis: Diese Test-Middleware unterstützt nur Benutzerinformationen in Ansprüchen. Das Abrufen von Benutzerinformationen in Sitzungen und Headern ist im Premium-Plugin verfügbar.

• Erstellen Sie auf der .NET-Seite einen GET-Endpunkt, um das JWT-Token nach der Anmeldung zurückzugeben.
  Hinweis: Wenn Sie über eine Methode zum Erstellen eines JWT verfügen, müssen Sie nur die Ansprüche aus dem .NET-Cookie auswählen.
  Unten ist der Code zu Ihrer Information:
[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. Schaltfläche „Anmelden“ hinzufügen

• Schweben Wählen Sie Aktionen aus und klicken Sie auf SSO-Link kopieren.

• Verwenden Sie die folgende URL als Link in der Anwendung, von der aus Sie SSO durchführen möchten:
https://<application-url>?ssoaction=login&appid=<app-id>

• Nach dem Login werden Sie zurück zu Ihrem Frontend-Anwendung, dann müssen Sie eine API-Aufruf um das zu bekommen Zeichen und Benutzerinformationen.

• Unten sehen Sie den Beispielcode, den Sie für den API-Aufruf an die Token-Endpunkt um das Token von der Frontend-Seite zu erhalten.
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. Testintegration

• Starten Sie Ihre ASP.NET Core Web-API-Anwendung

• Starten Sie Ihre Frontend-Anwendung

• Klicken Sie in der Frontend-Anwendung auf das SSO-Anmeldung Schaltfläche, die Sie hinzugefügt haben

• Nach SAML-Anmeldung, Sie werden zurück zu Ihrer Frontend-Anwendung geleitet. An diesem Punkt ruft Ihre Frontend-Anwendung die /api/gettoken -Endpunkt, der das Token und die Benutzerdetails zurückgibt. Sie können den JWT-Token um Ihre weiteren API-Aufrufe zu tätigen.

Hinweis: Wenn Sie das Attribut „Authorize“ der API zur Tokenvalidierung verwenden, müssen Sie die Authentifizierungsrichtlinie angeben, da wir jetzt mehrere Richtlinien registriert haben.

Für JWT-Verwendung: [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]

Ähnliche Artikel

• ASP.NET SAML SSO
• ASP.NET OAuth SSO
• ASP.NET Zwei-Faktor-Authentifizierung (2FA)

Kontaktieren Sie uns

Bitte erreichen Sie uns unter aspnetsupport@xecurify.com, und unser Team unterstützt Sie bei der Einrichtung des ASP.NET Core SAML SSO. Unser Team hilft Ihnen, die am besten geeignete Lösung/den am besten geeigneten Plan entsprechend Ihren Anforderungen auszuwählen.