Exemplarische Vorgehensweise zu Ansprüchen: Erstellen von Forderungsanbietern für Webanwendungen mit formularbasierter Authentifizierung für SharePoint 2010

Artikel
06/24/2015

Zusammenfassung: Informationen zum Erstellen eines Anspruchsanbieters für eine Microsoft SharePoint 2010-Webanwendung mit formularbasierter Authentifizierung.

Letzte Änderung: Montag, 9. März 2015

Inhalt dieses Artikels
Übersicht über das Erstellen eines Anspruchsanbieters für eine Webanwendung mit formularbasierter Authentifizierung
Szenario: Verwenden von Ansprüchen für den Zugriff auf SharePoint-Ressourcen
Schlussfolgerung
Anhang A: Zeichenzuordnung für die Codierung von Identitätsansprüchen
Weitere Ressourcen

Bereitgestellt von: Andy Li, Microsoft Corporation

Inhalt

Übersicht über das Erstellen eines Anspruchsanbieters für eine Webanwendung mit formularbasierter Authentifizierung
Szenario: Verwenden von Ansprüchen für den Zugriff auf SharePoint-Ressourcen
Schlussfolgerung
Anhang A: Zeichenzuordnung für die Codierung von Identitätsansprüchen
Weitere Ressourcen

Code zum Herunterladen: ClaimsExample-ContosoClaimsProviders

Übersicht über das Erstellen eines Anspruchsanbieters für eine Webanwendung mit formularbasierter Authentifizierung

In dieser exemplarischen Vorgehensweise implementieren Sie ein Beispiel für einen CRM-Anspruchsanbieter (Customer Relationship Management, Kundenbeziehungsmanagement) für die formularbasierte Webanwendung, die Sie in Exemplarische Vorgehensweise zu Ansprüchen: Erstellen der formularbasierten Authentifizierung für anspruchsbasierte SharePoint 2010-Webanwendungen mithilfe benutzerdefinierter Mitgliedschafts- und Rollenanbieter erstellt haben. Anschließend ändern Sie den Anspruchsanbieter, um weitere CRM-Ansprüche (mithilfe der Anspruchserweiterung) bereitzustellen, die zum Steuern des Zugriffs auf SharePoint-Ressourcen mithilfe einer Zugriffssteuerungsliste (Access Control List, ACL) verwendet werden.

Standardmäßig werden Aufgaben mithilfe von Mitgliedschafts- und Rollenanbietern gesucht und aufgelöst, die die Schnittstellen implementieren, welche von Microsoft SharePoint Foundation 2010 und Microsoft SharePoint Server 2010 vom standardmäßigen Anspruchsanbieter für die formularbasierte Authentifizierung aufgerufen werden. Es kann Fälle geben, in denen zusätzliche Ansprüche benötigt werden (z. B. wie im Abschnitt mit dem Szenario für CRM erläutert). In diesen Fällen können Sie einen Anbieter für die Anspruchserweiterung verwenden.

Der Begriff Anspruchserweiterung gilt für jede Art von Anspruchsauthentifizierung: Windows-Anspruchsauthentifizierung, SAML-Anmeldung (Security Assertion Markup Language) und formularbasierte Authentifizierung.

Hinweis
Weitere Informationen zur Anspruchserweiterung finden Sie unter Exemplarische Vorgehensweise zu Ansprüchen: Schreiben von Anspruchsanbietern für SharePoint 2010.

Szenario: Verwenden von Ansprüchen für den Zugriff auf SharePoint-Ressourcen

Angenommen, Sie besitzen ein externes CRM-System mit einer völlig anderen Gruppe von Konteneinstellungen. Beim Anmelden am CRM-System gibt ein Benutzer einen anderen Benutzernamen und ein anderes Kennwort an. Nach der Anmeldung werden jedem Benutzer abhängig von den Kontoeinstellungen andere Berechtigungen vom CRM-System erteilt.

Jedes CRM-Konto besitzt zwei Attribute: Role und Region. Das Role-Attribut gibt an, ob der aktuelle Benutzer ein Vertriebsmitarbeiter, ein Vertriebsmanager oder ein Mitglied der Geschäftsleitung ist. Mit dem Region-Attribut wird angezeigt, wo sich der Benutzer befindet.

In Microsoft SharePoint 2010 ist eine Websiteauflistung zum Speichern von Dokumenten vorhanden, die mit CRM in Verbindung stehen. Die Idee besteht darin, dass beim Anmelden eines Benutzers an der SharePoint-Website die Rollen- und Regionsinformationen aus dem CRM-System übernommen werden, sodass Berechtigungen für Dokumente basierend auf diesen CRM-Informationen zu Rolle und Region erzwungen werden.

Schritt 1: Vorbereiten des Projekts

Zunächst müssen Sie das SharePoint-Projekt vorbereiten.

So bereiten Sie das Projekt vor

Erstellen Sie ein leeres SharePoint-Projekt.
Nennen Sie das Projekt ContosoClaimProviders.
Wenn Sie zur Angabe der SharePoint-Website zum Debuggen aufgefordert werden, geben Sie http://intranet.contoso.com:200 ein. Auf dieser Website werden die Ansprüche für die formularbasierte Authentifizierung aktiviert.
Fügen Sie einen Verweis auf die Microsoft.IdentityModel.dll-Assembly hinzu.

Schritt 2: Hinzufügen der Funktion zum Nachschlagen des Benutzers

Als Nächstes fügen Sie eine Funktion zum Nachschlagen von Benutzerinformationen hinzu.

So fügen Sie die Funktion zum Nachschlagen von Benutzern hinzu

Fügen Sie dem Projekt eine Klassendatei mit dem Namen CRMClaimTypes.cs hinzu.

Fügen Sie die folgenden Namespaces hinzu.

using Microsoft.SharePoint.Administration;
using Microsoft.IdentityModel.Claims;
using System.Collections;

Ersetzen Sie den Code der Datei CRMClaimTypes.cs durch den folgenden Code. Mit der CRMClaimType-Klasse werden die beiden benutzerdefinierten Ansprüche definiert, die von unserem Anspruchsanbieter unterstützt werden.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ContosoClaimProviders
{
    public class CRMClaimType
    {
        public static string Role = "http://schemas.sample.org/ws/2009/12/identity/claims/CRMRole";
        public static string Region = "http://schemas.sample.org/ws/2009/12/identity/claims/CRMRegion";
    }
}

Fügen Sie eine Klassendatei mit dem Namen CRMUserInfo.cs hinzu. Die CRMUseInfo-Klasse stellt die Unterstützung für das Nachschlagen von Benutzerinformationen bereit. Der folgende Code wird nur zu Demonstrationszwecken bereitgestellt. Bei einer Produktionsimplementierung sollten die Benutzerinformationen an einem sicheren Ort gespeichert werden, oder die Daten sollten in den Verzeichnisdiensten oder in einer Datenbank nachgeschlagen werden.

Fügen Sie der CRMUseInfo-Klasse den folgenden Code hinzu.

        private static string[] userDB = 
           {
            "bob:CRMRole:Reader", 
            "bob:CRMRole:SalesRepresentative",
            "bob:CRMRegion:Northwest",
            "mary:CRMRole:Reader",
            "mary:CRMRole:SalesManager",
            "mary:CRMRegion:East",
            "jack:CRMRole:Reader",
            "jack:CRMRole:Executive",
            "jack:CRMRegion:East",
            "admin1:CRMRole:Administrator",
            "contoso\\andy:CRMRole:SalesManager",
             contoso\\administrator:CRMRole:SalesManager
           };

        private static string[] claimsDB = 
           {"CRMRole:Reader", 
            "CRMRole:SalesRepresentative",
            "CRMRole:SalesManager",
            "CRMRole:Executive",
            "CRMRole:Administrator",
            "CRMRegion:Northwest",
            "CRMRegion:East",
            };

Fügen Sie eine statische Methode mit dem Namen GetClaimsForUser hinzu. Dies ist eine Hilfsmethode, die alle Ansprüche für einen bestimmten Benutzer zurückgibt.

        public static List<Claim> GetClaimsForUser(string username)
        {
             List<Claim> userClaims = new List<Claim>();
            foreach(string userInfo in userDB)
            {
                string[] claims = userInfo.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
                if (username == claims[0])
                {
                    userClaims.Add(new Claim(GetClaimTypeForRole(claims[1]), claims[2], Microsoft.IdentityModel.Claims.ClaimValueTypes.String));
                }
            }

            return userClaims;
        }

Fügen Sie eine statische Methode mit dem Namen GetAllUsers hinzu. Dies ist eine weitere Hilfsmethode, die alle Kontonamen eines Benutzers zurückgibt.

        // Manually constructs a list of users. In a real-world 
        // production environment, you should look up a directory service
        // or database to retrieve the user information.
        public static List<string> GetAllUsers()
        {
            List<string> allUsers = new List<string>();

            // Add forms users.
            allUsers.Add("bob");
            allUsers.Add("mary");
            allUsers.Add("jack");
            allUsers.Add("admin1");

            // Add Windows domain user if you want this provider
            // to augment the claims.
            allUsers.Add("contoso\\andy");
            return allUsers;
        }

Fügen Sie der CRMUserInfo-Klasse die folgenden zwei Methoden hinzu.

Die GetAllClaims-Methode gibt alle bekannten Anspruchswerte zurück, die von diesem Anbieter unterstützt werden. Alle Werte sind im Zeichenfolgenarray claimsDB definiert.

Die Hilfsmethode GetClaimTypeForRole übersetzt einen Anspruchstyp von seinem Zeichenfolgennamen in den tatsächlichen Anspruchstyp. CRMRole wird beispielsweise zu http://schemas.sample.org/ws/2009/12/identity/claims/CRMRole.

        /// <summary>
        /// This method returns all the known claims from the CRM system  
        /// so that the claims provider is able to search and resolve 
        /// the claims in People Picker.
        /// </summary>
        /// <returns></returns>
        public static Hashtable GetAllClaims()
        {
            Hashtable knownClaims = new Hashtable();
            foreach(string claimItem in claimsDB)
            {
                string[] claim = claimItem.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
                knownClaims.Add(claim[1].ToLower(), claim[0].ToLower());
            }
            return knownClaims;
        }


        public static string GetClaimTypeForRole(string roleName)
        {
            if (roleName.Equals("CRMRole", StringComparison.OrdinalIgnoreCase))
                return CRMClaimType.Role;
            else if (roleName.Equals("CRMRegion", StringComparison.OrdinalIgnoreCase))
                return CRMClaimType.Region;
            else
                throw new Exception("CRM claim type not found!");
        }

Schritt 3: Erstellen des Anspruchsanbieters

Im nächsten Schritt implementieren Sie einen Anspruchsanbieter.

So implementieren Sie den Anspruchsanbieter

Fügen Sie eine Klassendatei mit dem Namen CRMClaimProvider.cs hinzu.

Fügen Sie die folgenden Namespaces hinzu.

using Microsoft.SharePoint.Administration.Claims;
using Microsoft.IdentityModel.Claims;
using System.Collections;
using Microsoft.SharePoint.WebControls;

Ändern Sie die Vererbung der CRMClaimProvider-Klasse in die SPClaimProvider-Klasse.
```
public class CRMClaimProvider : SPClaimProvider
```

Fügen Sie den folgenden Code hinzu, um die Konstruktion der Name-Eigenschaft zu unterstützen.

        public CRMClaimProvider(string displayName)
            : base(displayName)
        {
        }

        public override string Name
        {
            get { return "ContosoCRMClaimProvider"; }
        }

Fügen Sie der Klasse den folgenden Code hinzu. Wie die Eigenschaftsnamen annehmen lassen, wird von den Eigenschaften entweder true oder false zurückgegeben, um jede einzelne Methode zu unterstützen.

Hinweis
Ein Beispiel zum Implementieren einer Hierarchie finden Sie unter Exemplarische Vorgehensweise zu Ansprüchen: Schreiben von Anspruchsanbietern für SharePoint 2010.

       /// <summary>
        /// Return true if you are doing claims augmentation.
        /// </summary>
        public override bool SupportsEntityInformation
        {
            get { return true; }
        }

        /// <summary>
        /// Return true if you support claims resolution in the People Picker.
        /// </summary>
        public override bool SupportsResolve
        {
            get { return true; }
        }

        /// <summary>
        /// Return true if you support claims search in the People Picker.
        /// </summary>
        public override bool SupportsSearch
        {
            get { return true; }
        }

        /// <summary>
        /// Return true if you support hierarchy display in the People Picker.
        /// </summary>
        public override bool SupportsHierarchy
        {
            get { return false; }
        }

                public override bool SupportsUserSpecificHierarchy
        {
            get
            {
                return base.SupportsUserSpecificHierarchy;
            }
        }

Fügen Sie der Klasse die folgenden Methoden hinzu:

FillClaimTypes Von SharePoint 2010 aufgerufen, um die vom Anspruchsanbieter unterstützten Anspruchstypen abzurufen.
FillClaimValueTypes Von SharePoint 2010 aufgerufen, um die entsprechenden Anspruchswerttypen für jeden unterstützten Anspruchstyp abzurufen.
FillSchema Von der Personenauswahl aufgerufen, um die Informationen abzurufen, die in der Personenauswahl angezeigt werden können.
FillEntityTypes Informiert die Personenauswahl über die vom Anspruchsanbieter unterstützten Anspruchstypen (d. h. Benutzer oder Rolle).

        /// <summary>
        /// Returns all the claim types that are supported by 
        /// this claims provider.
        /// </summary>
        /// <param name="claimTypes"></param>
        protected override void FillClaimTypes(List<string> claimTypes)
        {
            if (null == claimTypes)
            {
                throw new ArgumentNullException("claimTypes");
            }

            // Add the claim types that will be added by this claims provider.  
            claimTypes.Add(CRMClaimType.Role);
            claimTypes.Add(CRMClaimType.Region);
        }

        /// <summary>
        /// Return all the claim value types that correspond to the claim  
        /// types. You must return the values in the same order as 
        /// in the FillClaimTypes method. 
        /// </summary>
        /// <param name="claimValueTypes"></param>
        protected override void FillClaimValueTypes(List<string> claimValueTypes)
        {

            if (null == claimValueTypes)
            {
                throw new ArgumentNullException("claimValueTypes");
            }

            claimValueTypes.Add(Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
            claimValueTypes.Add(Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
        }

        /// <summary>
        /// Required for People Picker. This tells the People Picker what 
        /// information is available for the entity.
        /// </summary>
        /// <param name="schema"></param>
        protected override void FillSchema(SPProviderSchema schema)
        {
            schema.AddSchemaElement(new SPSchemaElement(PeopleEditorEntityDataKeys.DisplayName,
                                                        "DisplayName",
                                                         SPSchemaElementType.TableViewOnly));
        }

        /// <summary>
        /// Returns the entity type for the claims that are returned from the 
        /// claims provider.
        /// </summary>
        /// <param name="entityTypes"></param>
        protected override void FillEntityTypes(List<string> entityTypes)
        {
            entityTypes.Add(SPClaimEntityTypes.FormsRole);
            entityTypes.Add(SPClaimEntityTypes.FormsRole);
        }

Fügen Sie die FillClaimsForEntity-Methode hinzu, um die Anspruchserweiterung zu unterstützen. Diese Methode wird vom SharePoint-Sicherheitstokendienst (Security Token Services, STS) aufgerufen, nachdem der Benutzer authentifiziert wurde.

      /// <summary>
        /// Implement this method if the claims provider supports
        /// claims augmentation.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="entity"></param>
        /// <param name="claims"></param>
        protected override void FillClaimsForEntity(Uri context, SPClaim entity, List<SPClaim> claims)
        {
            if (null == entity)
            {
                throw new ArgumentNullException("entity");
            }
            if (null == claims)
            {
                throw new ArgumentNullException("claims");
            }

            // Add the role claim.
            SPClaim userIdClaim = SPClaimProviderManager.DecodeUserIdentifierClaim(entity);

            // Add claims for users.
            List<string> allCRMUsers = CRMUserInfo.GetAllUsers();

            if(allCRMUsers.Contains(userIdClaim.Value.ToLower()))
            {
                List<Claim> userClaims = CRMUserInfo.GetClaimsForUser(userIdClaim.Value.ToLower());
                foreach(Claim claim in userClaims)
                {
                    claims.Add(CreateClaim(claim.ClaimType, claim.Value, claim.ValueType));
                }

            }

        }

Fügen Sie die FillSearch-Methode hinzu, um die Suche nach Ansprüchen zu unterstützen.

       /// <summary>
        /// Required if you implement the claims search in the People Picker.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="entityTypes"></param>
        /// <param name="searchPattern"></param>
        /// <param name="hierarchyNodeID"></param>
        /// <param name="maxCount"></param>
        /// <param name="searchTree"></param>
        protected override void FillSearch(Uri context, string[] entityTypes, string searchPattern, string hierarchyNodeID, int maxCount, SPProviderHierarchyTree searchTree)
        {
            string keyword = searchPattern.ToLower();
            Hashtable knownClaims = CRMUserInfo.GetAllClaims();
            List<string> knownClaimsList = new List<string>();

            // Convert the knownClaims.Key into a List<string> for LINQ query.
            foreach (string claim in knownClaims.Keys)
            {
                knownClaimsList.Add(claim);
            }


            var claimQuery = knownClaimsList.Where(claim => claim.IndexOf(keyword) >= 0).Select(claim => claim);

            foreach (string claimValue in claimQuery)
            {
                // Get the ClaimType for the claim type.
                // For example, if you search "SalesManager", 
                // the ClaimType will be CRMClaimType.Role.

                string claimType = CRMUserInfo.GetClaimTypeForRole((string)knownClaims[claimValue]);

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaim(claimType, claimValue, Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = claimValue;
                entity.EntityType = SPClaimEntityTypes.FormsRole;
                entity.IsResolved = true;
                searchTree.AddEntity(entity);
            }

        }

Fügen Sie die folgenden beiden FillResolve-Methoden hinzu, um die Anspruchsauflösung in der Personenauswahl zu unterstützen.

        /// <summary>
        /// Resolve a single claim by using exact match. This method is required
        /// for claim search and for claim resolve.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="entityTypes"></param>
        /// <param name="resolveInput"></param>
        /// <param name="resolved"></param>
        protected override void FillResolve(Uri context, string[] entityTypes, SPClaim resolveInput, List<PickerEntity> resolved)
        {
            string keyword = resolveInput.Value.ToLower();
            Hashtable knownClaims = CRMUserInfo.GetAllClaims();

            if (knownClaims.ContainsKey(keyword))
            {

                // Get the ClaimType for the claim type.
                // For example, if you search "SalesManager", 
                // the ClaimType will be CRMClaimType.Role.
                // In this case, the keyword is the value of the claim.
                string claimValue = keyword;
                string claimType = CRMUserInfo.GetClaimTypeForRole((string)knownClaims[keyword]);

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaim(claimType, claimValue, Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = claimValue;
                entity.EntityType = SPClaimEntityTypes.FormsRole;
                entity.IsResolved = true;
                resolved.Add(entity);
            }
        }


        /// <summary>
        /// Required if you implement claim resolution in the People Picker.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="entityTypes"></param>
        /// <param name="resolveInput"></param>
        /// <param name="resolved"></param>
        protected override void FillResolve(Uri context, string[] entityTypes, string resolveInput, List<PickerEntity> resolved)
        {

            string keyword = resolveInput.ToLower();
            Hashtable knownClaims = CRMUserInfo.GetAllClaims();
            List<string> knownClaimsList = new List<string>();

            // Convert the knownClaims.Key into a List<string> for LINQ query.
            foreach (string claim in knownClaims.Keys)
            {
                knownClaimsList.Add(claim);
            }

            var claimQuery = knownClaimsList.Where(claim => claim.IndexOf(keyword) >= 0).Select(claim => claim);

            foreach (string claimValue in claimQuery)
            {

                // Get the ClaimType for the claim type.
                // For example, if you search "SalesManager", 
                // the ClaimType will be CRMClaimType.Role.

                string claimType = CRMUserInfo.GetClaimTypeForRole((string)knownClaims[claimValue]);

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaim(claimType, claimValue, Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = claimValue;
                entity.EntityType = SPClaimEntityTypes.FormsRole;
                entity.IsResolved = true;
                resolved.Add(entity);
            }

        }

Fügen Sie die folgende FillHierarchy-Methode hinzu. Diese Methode ist zum Implementieren aller Funktionen für eine abstrakte Klasse erforderlich.

Hinweis

Ein Beispiel zum Implementieren einer Hierarchie finden Sie unter Exemplarische Vorgehensweise zu Ansprüchen: Schreiben von Anspruchsanbietern für SharePoint 2010.
```
        protected override void FillHierarchy(Uri context, string[] entityTypes, string hierarchyNodeID, int numberOfLevels, SPProviderHierarchyTree hierarchy)
        {
            throw new NotImplementedException();
        }
```
Erstellen Sie das Projekt, und korrigieren Sie eventuell vorhandene Fehler.

Schritt 4: Bereitstellen eines Anspruchsanbieters

Im nächsten Schritt stellen Sie den Anspruchsanbieter bereit.

So stellen Sie den Anspruchsanbieter bereit

Fügen Sie im Projektmappen-Explorer ein Feature unter dem Knoten Features hinzu. Ändern Sie seinen Namen in CRMClaimProvider.
Klicken Sie mit der rechten Maustaste auf CRMClaimProvider, und klicken Sie dann auf Ereignisempfänger hinzufügen.
Ändern Sie das Feld Bereich des Features in Farm.
Fügen Sie den Namespace der Empfängerklassendatei hinzu.
```
using Microsoft.SharePoint.Administration.Claims;
```
Leiten Sie die Klasse von SPClaimProviderFeatureReceiver ab. Dieser Basisempfänger stellt die Funktion zum Registrieren des Anspruchs für die Farm bereit.
```
public class CRMClaimProviderEventReceiver : SPClaimProviderFeatureReceiver
```

Ersetzen Sie Implementierung für den Empfänger durch den folgenden Code.

       private string providerDisplayName = "CRM Claims Provider";
        private string providerDescription = "Provides claims from Contoso CRM system";

        public override string ClaimProviderAssembly
        {
            get { return typeof(ContosoClaimProviders.CRMClaimProvider).Assembly.FullName; }
        }
        public override string ClaimProviderType
        {
            get { return typeof(ContosoClaimProviders.CRMClaimProvider).FullName; }
        }
        public override string ClaimProviderDisplayName
        {
            get
            {
                return providerDisplayName;
            }
        }
        public override string ClaimProviderDescription
        {
            get
            {
                return providerDescription;
            }
        }

Erstellen Sie das Projekt, und stellen Sie es für die Farm bereit.

Schritt 5: Entfernen von Benutzern von der Website

Im nächsten Schritt entfernen Sie Benutzer.

So entfernen Sie Benutzer von einer Website

Wechseln Sie zu http://intranet.contoso.com:200.
Melden Sie sich mit den Anmeldeinformationen admin1/pass@word1 an.
Klicken Sie im Menü Websiteaktionen auf Websiteeinstellungen.
Klicken Sie im Abschnitt Benutzer und Berechtigungen auf Personen und Gruppen.
Klicken Sie im linken Navigationsbereich auf Weitere....
Entfernen Sie, falls vorhanden, bob, mary und jack.
Entfernen Sie, falls vorhanden, Employee, TeamManager und CEO.
Klicken Sie in der Dropdownliste in der oberen rechten Ecke auf Als anderer Benutzer anmelden.

Versuchen Sie, sich als Bob, Mary oder Jack anzumelden. Es sollte eine wie in Abbildung 1 dargestellte Fehlermeldung angezeigt werden.

Abbildung 1. Fehlermeldung 'Zugriff verweigert'

Fehlermeldung 'Zugriff verweigert'

Hinweis
Falls keine Fehlermeldung vom Typ Zugriff verweigert angezeigt wird, gehen Sie zurück zu den vorherigen Schritten, und stellen Sie sicher, dass Sie alle Benutzer und Rollen gelöscht haben, die Sie in Schritt 2: Hinzufügen der Funktion zum Nachschlagen des Benutzers hinzugefügt haben.

Schritt 6: Testen der Funktionalität der Anspruchssuche

Nun sollten Sie die Funktionalität der Anspruchssuche testen.

So testen Sie die Funktionalität der Anspruchssuche

Wechseln Sie zu http://intranet.contoso.com:200.
Melden Sie sich mit den Anmeldeinformationen admin1/pass@word1 an.
Klicken Sie im Menü Websiteaktionen auf Websiteberechtigungen.
Klicken Sie auf dem Menüband auf Berechtigungen erteilen. Das Dialogfeld Berechtigungen erteilen wird mit dem Symbol Durchsuchen unter Benutzer/Gruppen wie in Abbildung 2 dargestellt angezeigt.

Abbildung 2. Dialogfeld 'Berechtigungen erteilen' mit dem Symbol 'Personenauswahl'
Klicken Sie auf das Symbol zum Durchsuchen, um das Dialogfeld Personenauswahl wie in Abbildung 3 gezeigt zu öffnen.

Abbildung 3. Dialogfeld 'Personenauswahl'
Geben Sie im Suchfeld sales ein, und klicken Sie dann auf Suchen. Es sollten zwei Ergebnisse wie in Abbildung 4 dargestellt angezeigt werden.

Abbildung 4. Suchen nach mit 'sales' verbundenen Ansprüchen
Doppelklicken Sie auf jedes Ergebnis, um beide dem Feld Hinzufügen hinzuzufügen.
Klicken Sie auf OK, um die Personenauswahl zu schließen. Die Rolle salesmanager und die Rolle salesrepresentative sollten dem Feld Benutzer/Gruppen wie in Abbildung 5 dargestellt hinzugefügt worden sein.
Wählen Sie unter Berechtigungen erteilen die Option FBA Site Members [Contribute] aus.

Abbildung 5. Auswählen von 'FBA Site Members (Contributor)'
Klicken Sie auf OK.
Klicken Sie im linken Navigationsbereich auf FBA Site Members. Es sollte angezeigt werden, dass die Rollen salesmanager und salesrepresentative (Ansprüche) der Gruppe FBA Site Members wie in Abbildung 6 gezeigt hinzugefügt worden sind.

Abbildung 6. Die Rollen 'salesmanager' und 'salesrepresentative' befinden sich in der Gruppe 'FBA Site Members'
Klicken Sie in der Dropdownliste in der oberen rechten Ecke auf Als anderer Benutzer anmelden.
Versuchen Sie, sich als Bob oder Mary anzumelden.
Versuchen Sie dann, sich als Jack anzumelden. Können Sie sich anmelden? Falls bei der Anmeldung ein Fehler auftritt, warum ist dies der Fall?
Melden Sie sich nun mit den Anmeldeinformationen admin1/pass@word1 an.
Wiederholen Sie die Schritte 3 bis 10 dieses Verfahrens, um die Rolle Executive hinzuzufügen.
Melden Sie sich mit den Anmeldeinformationen von Jack an, und warten Sie ab, ob dies nun möglich ist.
Wiederholen Sie die Schritte 3 bis 10 dieses Verfahrens, um die Ansprüche East und Northwest der Region hinzuzufügen.
Testen Sie das Anmeldeverhalten für East und Northwest.

Schritt 6.1: Codieren von Ansprüchen

Im nächsten Schritt codieren Sie Ansprüche.

So codieren Sie die Ansprüche

Klicken Sie im Menü Websiteaktionen auf Websiteeinstellungen.
Klicken Sie im Abschnitt Benutzer und Berechtigungen auf Personen und Gruppen.

Klicken Sie auf der Seite Personen und Gruppen auf salesmanager, um Informationen zum Anspruch salesmanager anzuzeigen, wie in Abbildung 7 gezeigt.

Hinweis
Falls Sie die Rolle salesmanager noch nicht der Seite Personen und Gruppen hinzugefügt haben, holen Sie dies jetzt nach. Informationen zum Hinzufügen der Rolle salesmanager zur Seite Personen und Gruppen finden Sie unter Schritt 6: Testen der Funktionalität der Anspruchssuche.

Abbildung 7. Anspruch 'Salesmanager'

'salesmanager'-Anspruch

Sehen Sie sich den Account-Namen an, und verwenden Sie die Codierungstabelle in Anhang A: Zeichenzuordnung für die Codierung von Identitätsansprüchen, um jedes Zeichen zu entschlüsseln.

Schritt 7: Testen der Funktionalität der Anspruchsauflösung

Im nächsten Schritt testen Sie die Funktionalität der Anspruchsauflösung.

So testen Sie die Funktionalität der Anspruchsauflösung

Wiederholen Sie Schritt 5: Entfernen von Benutzern von der Website, um alle Benutzeransprüche zu entfernen, die Sie der Website hinzugefügt haben.
Wechseln Sie zu http://intranet.contoso.com:200.
Melden Sie sich mit den Anmeldeinformationen admin1/pass@word1 an.
Klicken Sie im Menü Websiteaktionen auf Websiteberechtigungen.
Klicken Sie auf dem Menüband auf Berechtigungen erteilen. Das Dialogfeld Berechtigungen erteilen wird mit dem Symbol Durchsuchen unter Benutzer/Gruppen wie in Abbildung 8 dargestellt angezeigt.

Abbildung 8. Dialogfeld 'Berechtigungen erteilen' mit dem Symbol 'Personenauswahl'
Geben Sie salesmanager in das Textfeld Benutzer/Gruppen ein. Klicken Sie unten rechts im Textfeld Benutzer/Gruppen auf das Symbol Namen prüfen, um den Namen wie in Abbildung 9 dargestellt aufzulösen.

Abbildung 9. Auflösen des Anspruchs 'salesmanager'
Klicken Sie auf OK, um den Anspruch salesmanager der Gruppe FBA Site Members hinzuzufügen.
Wiederholen Sie die vorherigen Schritte in diesem Verfahren, um das Anmeldeverhalten für Bob, Mary und Jack zu testen.
Geben Sie im Textfeld Benutzer/Gruppe den Begriff sales ein, um eine Platzhaltersuche durchzuführen. Es sollten wie in Abbildung 10 dargestellt mehrere Entitäten zurückgegeben werden.

Hinweis

Der Anspruchsanbieter kann hier nicht wie im Dialogfeld Durchsuchen angegeben werden. Sie können jedoch auf Weitere Namen klicken, um das Dialogfeld Durchsuchen zu öffnen.

Abbildung 10. Platzhaltersuche

Hinweis
Der Anspruchsanbieter kann hier nicht wie im Dialogfeld Durchsuchen angegeben werden. Sie können jedoch auf Weitere Namen klicken, um das Dialogfeld Durchsuchen zu öffnen.

Schritt 8: Debuggen eines Anspruchsanbieters

Im nächsten Schritt wenden Sie die Kenntnisse aus den vorherigen Testschritten an und debuggen die Anspruchserweiterung sowie den Such- und Auflösungsprozess:

Wenn Sie den Prozess der Anspruchserweiterung debuggen, müssen Sie - für den SharePoint-Sicherheitstokendienst (Security Token Services, STS) - an w3wp.exe anfügen.
Falls Sie die Anspruchssuche oder Anspruchsauflösung für die Webanwendung debuggen, fügen Sie an w3wp.exe an.
Falls Sie Änderungen am Anspruchsanbieter vorgenommen haben, müssen Sie iisreset ausführen, da der SharePoint-STS-Prozess von Microsoft Visual Studio 2010 nicht wiederverwendet wird. Der STS-Prozess verweist möglicherweise immer noch auf die alte Version des Anspruchsanbieters.

Schritt 9: Hinzufügen der Unterstützung für ein Windows-Konto

Im nächsten Schritt aktivieren Sie die Unterstützung für die Windows-Authentifizierung und die formularbasierte Authentifizierung für http://intranet.contoso.com:200.

So fügen Sie die Unterstützung für ein Windows-Konto hinzu

Starten Sie die Website für die Zentraladministration.
Klicken Sie im linken Navigationsbereich auf Sicherheit.
Klicken Sie im Abschnitt Allgemeine Sicherheit auf Authentifizierungsanbieter angeben.
Wählen Sie in der Dropdownliste Webanwendung die Option http://intranet.contoso.com:200 aus.
Klicken Sie unter Zone wie in Abbildung 11 gezeigt auf Standard.

Abbildung 11. Seite mit Authentifizierungsanbietern
Aktivieren Sie das Kontrollkästchen Windows-Authentifizierung aktivieren, und wählen Sie dann wie in Abbildung 12 dargestellt Integrierte Windows-Authentifizierung aus.

Abbildung 12. Auswählen von Anspruchsauthentifizierungtypen
Klicken Sie auf Speichern.
Führen Sie iisreset aus.

Geben Sie den Quellcode des Anspruchsanbieters zurück, und stellen Sie sicher, dass Sie dem userDB-Array Ihr Domänenkonto hinzugefügt haben.

Hinweis
In diesem Beispiel wurde die SalesManager-Rolle für contoso\administrator hinzugefügt.

        private static string[] userDB = 
           {
            "bob:CRMRole:Reader", 
            "bob:CRMRole:SalesRepresentative",
            "bob:CRMRegion:Northwest",
            "mary:CRMRole:Reader",
            "mary:CRMRole:SalesManager",
            "mary:CRMRegion:East",
            "jack:CRMRole:Reader",
            "jack:CRMRole:Executive",
            "jack:CRMRegion:East",
            "admin1:CRMRole:Administrator",
            "contoso\\andy:CRMRole:SalesManager",
             contoso\\administrator:CRMRole:SalesManager
           };

Wechseln Sie zu http://intranet.contoso.com:200.
Melden Sie sich mit den Anmeldeinformationen admin1/pass@word1 an.
Klicken Sie im Menü Websiteaktionen auf Websiteberechtigungen.
Erteilen Sie der SalesManager-Rolle die Berechtigung für die Website, falls dies noch nicht geschehen ist.
Klicken Sie in der Dropdownliste in der oberen rechten Ecke auf Als anderer Benutzer anmelden.
Die Seite Mehrere Authentifizierungsmethoden wird wie in Abbildung 13 dargestellt geöffnet.

Abbildung 13. Seite 'Mehrere Authentifizierungsmethoden'

Wählen Sie in der Dropdownliste die Option Windows-Authentifizierung aus. Die Anmeldung an der Website sollte automatisch erfolgen.

Hinweis
Wenn Sie Windows-Authentifizierung auswählen, werden Sie zu /_windows/default.aspx umgeleitet, wodurch eine automatische NTLM-Authentifizierung durchgeführt wird. Sie werden dann wieder zur Website umgeleitet.

Sehen Sie sich das Webpart zum Anzeigen von Ansprüchen sowie die Ansprüche an, die für contoso\administrator hinzugefügt wurden.

Schritt 10: Ändern des Anspruchsbereichs

Diesen Schritt führen Sie selbständig aus. Die Aufgabe besteht darin, eine Websitesammlung unter http://intranet.contoso.com/sites/CRMDocs zu erstellen. Fügen Sie der Website dann Folgendes hinzu:

Dokumentbibliothek: CustomerDocs
Benutzerdefinierte Liste: East_Customers

Nur dieser Anspruchsanbieter soll für diese Website zur Verfügung stehen.

Folgende Ziele sollen erreicht werden:

Falls sich ein Benutzer an http://intranet.contoso.com anmeldet, sollen sich keine CRM-Ansprüche im Anspruchstoken des Benutzers befinden. Das Webpart zum Anzeigen von Ansprüchen zeigt keine mit CRM verbundenen Ansprüche an.
Nur Benutzer mit CRMRole=Reader können sich an der http://intranet.contoso.com/sites/CRMDocs-Website anmelden.
Benutzer mit CRMRole=Executive können auf die CustomerDocs-Bibliothek zugreifen.
Benutzer mit CRMRegion=East können auf die East_Customers-Liste zugreifen.

Wenden Sie die erworbenen Kenntnisse an, und vervollständigen Sie die Aufgabe. Für ein besseres Verständnis und als Erinnerung können Sie den Code aufschreiben.

Schlussfolgerung

In dieser exemplarischen Vorgehensweise lernen Sie das Erstellen eines Anspruchsanbieters für eine SharePoint 2010-Webanwendung, die die formularbasierte Authentifizierung verwendet, und Sie testen den von Ihnen erstellten Anspruchsanbieter.

Anhang A: Zeichenzuordnung für die Codierung von Identitätsansprüchen

Tabelle 1. Codierung von Anspruchstypen

Zeichen	Anspruchstyp
!	SPClaimTypes.IdentityProvider
"	SPClaimTypes.UserIdentifier
#	SPClaimTypes.UserLogonName
$	SPClaimTypes.DistributionListClaimType
%	SPClaimTypes.FarmId
&	SPClaimTypes.ProcessIdentitySID
‘	SPClaimTypes.ProcessIdentityLogonName
(	SPClaimTypes.IsAuthenticated
)	Microsoft.IdentityModel.Claims.ClaimTypes.PrimarySid
*	Microsoft.IdentityModel.Claims.ClaimTypes.PrimaryGroupSid
+	Microsoft.IdentityModel.Claims.ClaimTypes.GroupSid
-	Microsoft.IdentityModel.Claims.ClaimTypes.Role
.	System.IdentityModel.Claims.ClaimTypes.Anonymous
/	System.IdentityModel.Claims.ClaimTypes.Authentication
0	System.IdentityModel.Claims.ClaimTypes.AuthorizationDecision
1	System.IdentityModel.Claims.ClaimTypes.Country
2	System.IdentityModel.Claims.ClaimTypes.DateOfBirth
3	System.IdentityModel.Claims.ClaimTypes.DenyOnlySid
4	System.IdentityModel.Claims.ClaimTypes.Dns
5	System.IdentityModel.Claims.ClaimTypes.Email
6	System.IdentityModel.Claims.ClaimTypes.Gender
7	System.IdentityModel.Claims.ClaimTypes.GivenName
8	System.IdentityModel.Claims.ClaimTypes.Hash
9	System.IdentityModel.Claims.ClaimTypes.HomePhone
<	System.IdentityModel.Claims.ClaimTypes.Locality
=	System.IdentityModel.Claims.ClaimTypes.MobilePhone
>	System.IdentityModel.Claims.ClaimTypes.Name
?	System.IdentityModel.Claims.ClaimTypes.NameIdentifier
@	System.IdentityModel.Claims.ClaimTypes.OtherPhone
[	System.IdentityModel.Claims.ClaimTypes.PostalCode
\	System.IdentityModel.Claims.ClaimTypes.PPID
]	System.IdentityModel.Claims.ClaimTypes.Rsa
^	System.IdentityModel.Claims.ClaimTypes.Sid
_	System.IdentityModel.Claims.ClaimTypes.Spn
`	System.IdentityModel.Claims.ClaimTypes.StateOrProvince
a	System.IdentityModel.Claims.ClaimTypes.StreetAddress
b	System.IdentityModel.Claims.ClaimTypes.Surname
c	System.IdentityModel.Claims.ClaimTypes.System
d	System.IdentityModel.Claims.ClaimTypes.Thumbprint
e	System.IdentityModel.Claims.ClaimTypes.Upn
f	System.IdentityModel.Claims.ClaimTypes.Uri
g	System.IdentityModel.Claims.ClaimTypes.Webpage

Tabelle 2. Codierung von Anspruchswerttypen

Zeichen	Anspruchstyp
!	Microsoft.IdentityModel.Claims.ClaimValueTypes.Base64Binary
"	Microsoft.IdentityModel.Claims.ClaimValueTypes.Boolean
#	Microsoft.IdentityModel.Claims.ClaimValueTypes.Date
$	Microsoft.IdentityModel.Claims.ClaimValueTypes.Datetime
%	Microsoft.IdentityModel.Claims.ClaimValueTypes.DaytimeDuration
&	Microsoft.IdentityModel.Claims.ClaimValueTypes.Double
‘	Microsoft.IdentityModel.Claims.ClaimValueTypes.DsaKeyValue
(	Microsoft.IdentityModel.Claims.ClaimValueTypes.HexBinary
)	Microsoft.IdentityModel.Claims.ClaimValueTypes.Integer
*	Microsoft.IdentityModel.Claims.ClaimValueTypes.KeyInfo
+	Microsoft.IdentityModel.Claims.ClaimValueTypes.Rfc822Name
-	Microsoft.IdentityModel.Claims.ClaimValueTypes.RsaKeyValue
.	Microsoft.IdentityModel.Claims.ClaimValueTypes.String
/	Microsoft.IdentityModel.Claims.ClaimValueTypes.Time
0	Microsoft.IdentityModel.Claims.ClaimValueTypes.X500Name
1	Microsoft.IdentityModel.Claims.ClaimValueTypes.YearMonthDuration

Weitere Ressourcen

Weitere Informationen finden Sie in den folgenden Ressourcen:

Freigeben über