Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Vorgehensweise: Verwenden des ACS-Verwaltungsdiensts zum Konfigurieren von Anwendungen der vertrauenden Seite

Veröffentlicht: April 2011

Letzte Aktualisierung: Juni 2015

Betrifft: Azure

  • Zugriffssteuerung für Microsoft Azure Active Directory (auch Zugriffssteuerungsdienst oder ACS)

Sie können ACS-Anwendungen der vertrauenden Seite mithilfe des ACS-Verwaltungsportals (weitere Informationen finden Sie unter Anwendungen der vertrauenden Seite) oder mithilfe des ACS-Verwaltungsdiensts konfigurieren. Die Verwendung des ACS-Verwaltungsdiensts kann effizienter sein, wenn Sie eine benutzerdefinierte Benutzerschnittstelle für die Verwaltung von ACS erstellen oder die Aufnahme eines neuen Mandanten für SaaS-Lösungen (Software as a Service, Software als Dienst) mit mehreren Mandanten automatisieren möchten.

ImportantWichtig
Bevor Sie die folgenden Schritte ausführen, stellen Sie sicher, dass Ihr System alle .NET Framework- und Plattformvoraussetzungen erfüllt, die unter ACS-Voraussetzungen zusammengefasst werden.

Führen Sie die folgenden Schritte aus, um Anwendungen der vertrauenden Seite mithilfe des ACS-Verwaltungsdiensts zu konfigurieren:

Sie können das ACS-Verwaltungsportal zum Erfassen der erforderlichen Konfigurationsinformationen verwenden. Weitere Informationen zum Starten des ACS-Verwaltungsportals finden Sie unter ACS-Verwaltungsportal.

  1. Starten Sie das ACS-Verwaltungsportal. Weitere Informationen zum Starten des ACS-Verwaltungsportals finden Sie unter ACS-Verwaltungsportal.

  2. Rufen Sie den Wert des ACS-Verwaltungsdienstkontos ab. Sie können das Standardkonto ManagementClient verwenden. Klicken Sie im ACS-Verwaltungsportal in der Struktur auf der linken Seite im Abschnitt Verwaltung auf Verwaltungsdienst, um diesen Wert anzuzeigen.

  3. Rufen Sie den Wert des Kennworts für das ACS-Verwaltungsdienstkonto ab. Gehen Sie wie folgt vor, um diesen Wert anzuzeigen:

    1. Klicken Sie im ACS-Verwaltungsportal in der Struktur auf der linken Seite im Abschnitt Verwaltung auf Verwaltungsdienst.

    2. Klicken Sie auf der Seite Verwaltungsdienst unter Verwaltungsdienstkonten auf ManagementClient.

    3. Klicken Sie auf der Seite Verwaltungsdienstkonto bearbeiten unter Anmeldeinformationen auf Kennwort.

    4. Kopieren Sie auf der Seite Verwaltungsanmeldeinformationen bearbeiten den Wert im Feld Kennwort.

  4. Rufen Sie den Namen Ihres Azure-Namespace ab. Sie können diesen Wert aus dem Azure-Portal oder aus der URL Ihres ACS-Verwaltungsportals abrufen. In http://contoso.accesscontrol.windows.net ist der Namespacename z. B. contoso.

  5. Rufen Sie den ACS-Hostnamen ab. Normalerweise lautet dieser accesscontrol.windows.net.

In diesem Schritt erstellen Sie eine Konsolenbeispielanwendung, die den Code zum Hinzufügen der ACS-Regelgruppen und -Regeln ausführen kann.

  1. Öffnen Sie Visual Studio 2012, und erstellen Sie dann ein neues Konsolenanwendungsprojekt unter der installierten Vorlage Windows.

  2. Fügen Sie der Klasse Program den folgenden Code hinzu, und weisen Sie dann die Variablen serviceIdentityPasswordForManagement, serviceNamespace und acsHostName den entsprechenden Konfigurationsinformationen zu, die Sie im vorherigen Schritt erfasst haben.

    public const string serviceIdentityUsernameForManagement = "ManagementClient";
    public const string serviceIdentityPasswordForManagement = "My Password/Key for ManagementClient";
    public const string serviceNamespace = "MyNameSpaceNoDots";
    public const string acsHostName = "accesscontrol.windows.net";
    public const string acsManagementServicesRelativeUrl = "v2/mgmt/service/";
    static string cachedSwtToken;
    
    

In diesem Schritt werden die erforderlichen Abhängigkeiten identifiziert und dann den Diensten und Assemblys hinzugefügt.

  1. Klicken Sie mit der rechten Maustaste auf Verweise, klicken Sie auf Verweis hinzufügen, und fügen Sie dann einen Verweis auf System.Web.Extensions hinzu.

    noteHinweis
    Ggf. müssen Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Namen Ihrer Konsolenbeispielanwendung klicken, Eigenschaften auswählen, und dann das Zielframework Ihrer Beispielanwendung von .NET Framework 4-Clientprofil (dieser Wert wird standardmäßig zugewiesen, wenn Sie eine neue Konsolenanwendung erstellen) in .NET Framework 4 ändern.

  2. Klicken Sie mit der rechten Maustaste auf Dienstverweise, klicken Sie auf Dienstverweis hinzufügen, und fügen Sie dem Verwaltungsdienst dann einen Dienstverweis hinzu. Die Verwaltungsdienst-URL ist für Ihren Namespace eindeutig und ähnelt der folgenden URL:

    https://IHRNAMESPACE.accesscontrol.windows.net/v2/mgmt/service

  3. Fügen Sie die folgenden Deklarationen hinzu. Dabei ist MyConsoleApplication der Name Ihrer Konsolenanwendung:

    using System;
    using System.IO;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Web;
    using System.Net;
    using System.Data.Services.Client;
    using System.Collections.Specialized;
    using System.Web.Script.Serialization;
    using System.Globalization;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates; 
    using MyConsoleApplication.MyServiceReference;
                  
    

In diesem Schritt implementieren Sie den Verwaltungsdienstclient.

  1. Fügen Sie der Klasse Program die folgende Methode hinzu:

       public static ManagementService CreateManagementServiceClient()
            {
                string managementServiceEndpoint = String.Format(CultureInfo.InvariantCulture, "https://{0}.{1}/{2}",
                    serviceNamespace,
                    acsHostName,
                    acsManagementServicesRelativeUrl);
                ManagementService managementService = new ManagementService(new Uri(managementServiceEndpoint));
    
                managementService.SendingRequest += GetTokenWithWritePermission;
    
                return managementService;
            }
    
    
  2. Fügen Sie die Methode GetTokenWithWritePermission und deren Hilfsmethoden der Klasse Program hinzu. GetTokenWithWritePermission und deren Hilfsmethoden fügen das SWT OAuth-Token des Autorisierungsheaders der HTTP-Anforderung hinzu.

    public static void GetTokenWithWritePermission(object sender, SendingRequestEventArgs args)
            {
                GetTokenWithWritePermission((HttpWebRequest)args.Request);
            }
    
            public static void GetTokenWithWritePermission(HttpWebRequest args)
            {
                if (cachedSwtToken == null)
                {
                    cachedSwtToken = GetTokenFromACS();
                }
    
                args.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + cachedSwtToken);
            }
    
            private static string GetTokenFromACS()
            {
                //
                // Request a token from ACS
                //
                WebClient client = new WebClient();
                client.BaseAddress = string.Format(CultureInfo.CurrentCulture, 
                                                   "https://{0}.{1}", 
                                                   serviceNamespace, 
                                                   acsHostName);
    
                NameValueCollection values = new NameValueCollection();
                values.Add("grant_type", "client_credentials");
                values.Add("client_id", serviceIdentityUsernameForManagement);
                values.Add("client_secret", serviceIdentityPasswordForManagement);
                values.Add("scope", client.BaseAddress + acsManagementServicesRelativeUrl);
    
                byte[] responseBytes = client.UploadValues("/v2/OAuth2-13", "POST", values);
    
                string response = Encoding.UTF8.GetString(responseBytes);
    
                // Parse the JSON response and return the access token 
                JavaScriptSerializer serializer = new JavaScriptSerializer();
    
                Dictionary<string, object> decodedDictionary = serializer.DeserializeObject(response) as Dictionary<string, object>;
    
                return decodedDictionary["access_token"] as string;
    
            }
    
    
    

In diesem Schritt erstellen Sie eine Beispielanwendung der vertrauenden Seite mit einem SAML 2.0-Tokenformat (Standardoption) ohne Tokenverschlüsselungsrichtlinie (Standardoption), die einem Windows Live ID (Microsoft-Konto)-Identitätsanbieter zugeordnet ist (Standardoption), deren Tokengültigkeitsdauer 600 Sekunden beträgt (Standardoption) und die ein benutzerdefiniertes X.509-Tokensignaturzertifikat für die Anwendung der vertrauenden Seite oder ein Tokensignaturzertifikat für den Namespace für die Zugriffssteuerung verwendet.

  1. Initialisieren Sie den Verwaltungsdienstclient, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

    ManagementService svc = CreateManagementServiceClient();
    
    
  2. Fügen Sie Ihre neue Anwendung der vertrauenden Seite hinzu (Sie können diese "MyRelyingPartyApplication" nennen, wie im Code unten gezeigt), und speichern Sie dann die Änderungen, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

    noteHinweis
    Ersetzen Sie "Full path to your .PFX file" im Code unten durch den gültigen vollständigen Pfad zu Ihrem X.509-Zertifikat. Wenn ein Zertifikat namens ACS2ClientCertificate.cer z. B. unter C:\ gespeichert wird, lautet der richtige Wert C:\ ACS2ClientCertificate.cer.

    Ersetzen Sie "MyCertificatePassword" im Code unten durch das richtige Kennwort für Ihr X.509-Zertifikat.

    
                //Create Relying Party Application
    
                RelyingParty relyingParty = new RelyingParty()
                {
                    Name = "MyRelyingPartyApplication",
                    AsymmetricTokenEncryptionRequired = false,
                    TokenType = "SAML_2_0",
                    TokenLifetime = 3600
                };
    
                svc.AddToRelyingParties(relyingParty);
    
    
                //Create the Realm Address
    
                RelyingPartyAddress realmAddress = new RelyingPartyAddress()
                {
                    Address = "http://TestRelyingParty.com/Realm",
                    EndpointType = "Realm"
                };
    
                svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", realmAddress);
    
                //Create the Return URL Address
    
                RelyingPartyAddress replyAddress = new RelyingPartyAddress()
                {
                    Address = "http://TestRelyingParty.com/Reply",
                    EndpointType = "Reply"
                };
    
                svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", replyAddress);
    
              // Create a Rule Group for This Relying Party Application
    
                RuleGroup rg = new RuleGroup();
                rg.Name = "SampleRuleGroup For " + relyingParty.Name;
                svc.AddToRuleGroups(rg);
    
                // Assign This New Rule Group to Your New Relying Party Application
    
                RelyingPartyRuleGroup relyingPartyRuleGroup = new RelyingPartyRuleGroup();
    
                svc.AddToRelyingPartyRuleGroups(relyingPartyRuleGroup);
                svc.AddLink(relyingParty, "RelyingPartyRuleGroups", relyingPartyRuleGroup);
                svc.AddLink(rg, "RelyingPartyRuleGroups", relyingPartyRuleGroup);
    
    
                //Save Your New Relying Party Application
    
                svc.SaveChanges(SaveChangesOptions.Batch);
    
    

  1. Initialisieren Sie den Verwaltungsdienstclient, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

    ManagementService svc = CreateManagementServiceClient();
    
    
  2. Erstellen Sie eine Hilfsfunktion ReadBytesFromPfxFile, die Bytes aus dem X.509-Zertifikat liest, indem Sie der Klasse Program den folgenden Code hinzufügen:

    //Helper Function to Read Bytes from Your .pfx file
    
            public static byte[] ReadBytesFromPfxFile(string pfxFileName, string protectionPassword)
            {
                byte[] signingCertificate;
                using (FileStream stream = File.OpenRead(pfxFileName))
                {
                    using (BinaryReader br = new BinaryReader(stream))
                    {
                        signingCertificate = br.ReadBytes((int)stream.Length);
                    }
                }
    
                return signingCertificate;
            }
    
    
  3. Fügen Sie Ihre neue Anwendung der vertrauenden Seite hinzu (Sie können diese "MyRelyingPartyApplication" nennen, wie im Code unten gezeigt), und speichern Sie dann die Änderungen, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

    noteHinweis
    Ersetzen Sie "Full path to your .PFX file" im Code unten durch den gültigen vollständigen Pfad zu Ihrem X.509-Zertifikat. Wenn ein Zertifikat namens ACS2ClientCertificate.cer z. B. unter C:\ gespeichert wird, lautet der richtige Wert C:\ ACS2ClientCertificate.cer.

    Ersetzen Sie "MyCertificatePassword" im Code unten durch das richtige Kennwort für Ihr X.509-Zertifikat.

    
                //Create Relying Party Application
    
                RelyingParty relyingParty = new RelyingParty()
                {
                    Name = "MyRelyingPartyApplication",
                    AsymmetricTokenEncryptionRequired = false,
                    TokenType = "SAML_2_0",
                    TokenLifetime = 3600
                };
    
                svc.AddToRelyingParties(relyingParty);
    
    
                //Create the Realm Address
    
                RelyingPartyAddress realmAddress = new RelyingPartyAddress()
                {
                    Address = "http://TestRelyingParty.com/Realm",
                    EndpointType = "Realm"
                };
    
                svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", realmAddress);
    
                //Create the Return URL Address
    
                RelyingPartyAddress replyAddress = new RelyingPartyAddress()
                {
                    Address = "http://TestRelyingParty.com/Reply",
                    EndpointType = "Reply"
                };
    
                svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", replyAddress);
    
                //Create a Signing Certificate
    
                X509Certificate2 cert = new X509Certificate2(@"Full path to your .PFX file", "MyCertificatePassword");
                DateTime startDate, endDate;
                startDate = cert.NotBefore.ToUniversalTime();
                endDate = cert.NotAfter.ToUniversalTime();
    
                string pfxFileName = @"Full path to your .PFX file";
                string pfxPassword = @"MyCertificatePassword";
    
                byte[] signingCertificate = ReadBytesFromPfxFile(pfxFileName, pfxPassword);
    
                RelyingPartyKey relyingPartyKey = new RelyingPartyKey()
                {
                    StartDate = startDate.ToUniversalTime(),
                    EndDate = endDate.ToUniversalTime(),
                    Type = "X509Certificate",
                    Usage = "Signing",
                    IsPrimary = true,
                    Value = signingCertificate,
                    Password = Encoding.UTF8.GetBytes("MyCertificatePassword")
                };
                svc.AddRelatedObject(relyingParty, "RelyingPartyKeys", relyingPartyKey);
    
    
              // Create a Rule Group for This Relying Party Application
    
                RuleGroup rg = new RuleGroup();
                rg.Name = "SampleRuleGroup For " + relyingParty.Name;
                svc.AddToRuleGroups(rg);
    
                // Assign This New Rule Group to Your New Relying Party Application
    
                RelyingPartyRuleGroup relyingPartyRuleGroup = new RelyingPartyRuleGroup();
    
                svc.AddToRelyingPartyRuleGroups(relyingPartyRuleGroup);
                svc.AddLink(relyingParty, "RelyingPartyRuleGroups", relyingPartyRuleGroup);
                svc.AddLink(rg, "RelyingPartyRuleGroups", relyingPartyRuleGroup);
    
    
                //Save Your New Relying Party Application
    
                svc.SaveChanges(SaveChangesOptions.Batch);
    
    

Siehe auch

Anzeigen: