Procédure pas à pas sur les revendications : création de fournisseurs de revendications pour les fournisseurs de connexions approuvés pour SharePoint 2010

Article
07/02/2015

Résumé : apprenez à créer un fournisseur de revendications pour un fournisseur de connexions approuvé, qui est un service d’émission de jeton de sécurité externe (c’est-à-dire, externe à SharePoint) approuvé par SharePoint.

Dernière modification : vendredi 18 janvier 2013

Dans cet article
Vue d’ensemble de la création d’un fournisseur de revendications pour un fournisseur de connexions approuvé
Étape 1 : création du projet du fournisseur de revendications
Étape 2 : création de la classe WingtipUserInfo qui stocke les informations utilisateur et qui permet d’interroger les revendications utilisateur
Étape 3 : ajout de code pour l’augmentation des revendications
Étape 4 : ajout de code pour l’exploration des revendications
Étape 5 : ajout de code pour la résolution des revendications
Étape 6 : inscription du projet WingtipClaimProvider auprès de WingtipSTS
Étape 7 : test du fournisseur de revendications
Conclusion
Ressources supplémentaires

Auteur : Andy Li, Microsoft Corporation

Contenu

Vue d’ensemble de la création d’un fournisseur de revendications pour un fournisseur de connexions approuvé
Étape 1 : création du projet du fournisseur de revendications
Étape 2 : création de la classe WingtipUserInfo qui stocke les informations utilisateur et qui permet d’interroger les revendications utilisateur
Étape 3 : ajout de code pour l’augmentation des revendications
Étape 4 : ajout de code pour l’exploration des revendications
Étape 5 : ajout de code pour la résolution des revendications
Étape 6 : inscription du projet WingtipClaimProvider auprès de WingtipSTS
Étape 7 : test du fournisseur de revendications
Conclusion
Ressources supplémentaires

Code à télécharger : exemple de fournisseur de connexions approuvé pour les revendications(éventuellement en anglais)

Vue d’ensemble de la création d’un fournisseur de revendications pour un fournisseur de connexions approuvé

Dans Procédure pas à pas concernant les revendications : création de fournisseurs de connexions approuvés (connexion SAML) pour SharePoint 2010, nous n’avons pas créé de fournisseur de revendications pour le fournisseur de connexions approuvé. Nous avons demandé à Microsoft SharePoint 2010 de générer un objet SPTrustedClaimProvider pour la résolution, le recensement et l’exploration des revendications à partir du fournisseur de connexions approuvé. Les revendications disponibles sont codées en dur lorsque l’objet SPTrustedLoginProvider, par exemple, idClaim.AddKnownClaimValue("user1@wingtip.com"), est créé et inscrit.

Dans cet exemple, nous créons un fournisseur de revendications personnalisé pour le fournisseur WingtipSTS. Cet exemple utilise un tableau de chaînes en mémoire pour stocker les informations sur les utilisateurs et les revendications. Dans une véritable implémentation, vous devez envisager l’interrogation d’un service d’annuaire pour le stockage des informations utilisateur dans une base de données.

Notes

Pour plus d’informations sur les fournisseurs de revendications, voir Fournisseur de revendications et Procédure pas à pas pour les revendications : écriture de fournisseurs de revendications pour SharePoint 2010.

Par défaut, SharePoint 2010 ne propose pas la fonctionnalité de recherche et de résolution dans le sélecteur de personnes pour les fournisseurs de connexions approuvés. Par conséquent, les résultats retournés par le sélecteur de personnes contiennent la chaîne tapée par l’utilisateur. Cela peut engendrer des problèmes, par exemple, si l’accès est accordé à un utilisateur, mais que celui-ci ne dispose toujours pas d’un accès. Toutefois, à ce jour, il n’existe pas de norme ou de protocole qui autorise la recherche et la résolution. Même s’il existait une norme ou un protocole, dans certains scénarios, cette fonctionnalité pourrait ne pas être disponible. Par exemple, dans Windows Live ID, il existe des scénarios où la recherche n’est pas autorisée pour des raisons de confidentialité.

La solution à ce problème consiste à utiliser un fournisseur de revendications personnalisé. Un fournisseur de revendications personnalisé peut implémenter un protocole spécifique pour autoriser la fonctionnalité de recherche et de résolution (sous réserve que cette fonctionnalité soit disponible) ou peut simplement effectuer une validation de base portant sur ce que l’utilisateur a tapé afin d’empêcher les erreurs. Par exemple, si le fournisseur de connexions approuvé est destiné à accorder aux utilisateurs Contoso l’accès au site Web de la société Fabrikam, mais que Contoso ne possède pas de protocole ou de service utilisable pour la recherche et la résolution, le fournisseur de revendications personnalisé permet de valider, par exemple, la présence systématique du suffixe « @contoso.com » dans les adresses de messagerie.

Notez que pendant l’inscription le nom du fournisseur de revendications doit correspondre au nom du fournisseur de connexions approuvé. En effet, la valeur de l’émetteur pour les revendications issues du fournisseur de connexions approuvé correspond au nom de ce fournisseur de connexions approuvé. Pendant la sélection, si le fournisseur de revendications personnalisé porte un nom différent, les revendications ajoutées par ce fournisseur de revendications via le sélecteur de personnes possèdent une valeur d’émetteur différente, ce qui entraînera une discordance pendant l’autorisation. Pour plus d’informations, voir Remplacement de la résolution de nom prête à l’emploi dans SharePoint 2010 : partie 2(éventuellement en anglais).

Il est important de définir le fournisseur de revendications affecté sur le fournisseur de connexions approuvé car, sinon, le fournisseur de revendications par défaut est utilisé en plus du fournisseur de revendications personnalisé, ce qui peut être source de confusion. Pour plus d’informations sur la façon de définir le fournisseur de revendications affecté sur le fournisseur de connexions approuvé, voir Comment remplacer la résolution de nom et le fournisseur de revendications par défaut dans SharePoint 2010(éventuellement en anglais).

Cet exemple d’article et de procédure pas à pas vise à résoudre le problème lié à la recherche et à la résolution pour les fournisseurs de connexions approuvés. En outre, un utilisateur peut également ajouter un fournisseur de revendications personnalisé à des fins d’augmentation, opération qui n’est pas illustrée dans cet article. La présence d’un fournisseur de revendications pour la prise en charge de la recherche et de la résolution dans ce cas et d’un second fournisseur de revendications pour l’augmentation des revendications (dans un scénario GRC) est une configuration valide.

Notes

Un fournisseur de connexions approuvé est un service d’émission de jeton de sécurité externe (c’est-à-dire, externe à SharePoint) approuvé par SharePoint. Pour plus d’informations sur les définitions des termes relatifs aux revendications, voir Définitions des termes de l’identité basée sur des demandes.

La connexion passive SAML décrit le processus de connexion. Lorsqu’une connexion à une application Web est configurée de façon à accepter les jetons provenant d’un fournisseur de connexions approuvé, ce type de connexion porte le nom de connexion passive SAML. Pour plus d’informations, voir Revendications entrantes : connexion à SharePoint.

Étape 1 : création du projet du fournisseur de revendications

Ouvrez le code téléchargeable pour la solution TrustedLogin qui accompagne cet article. Il contient normalement trois projets, comme l’illustre la figure 1 :
- site Web TestRPWeb ;
- site Web WingtipSTS ;
- application WinForm RegisterSTS.
  
  Figure 1. Trois projets inclus dans la solution TrustedLogin
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution TrustedLogin, sélectionnez Ajouter, puis cliquez sur Nouveau projet.
Sous Visual C#, sélectionnez le modèle Projet SharePoint vide, sélectionnez SharePoint, puis cliquez sur 2010. Nommez le projet SharePoint WingtipClaimProvider. Ensuite, procédez comme suit :
- Dans l’Assistant de personnalisation, sélectionnez Déployer en tant que solution de batterie.
- Tapez https://intranet.contoso.com comme site pour le débogage.
Dans le projet WingtipClaimProvider, ajoutez une référence à Microsoft.IdentityModel.dll.

Pour plus d’informations sur Microsoft.IdentityModel.dll, voir Windows Identity Foundation.
Cliquez avec le bouton droit sur le projet WingtipClaimProvider, sélectionnez Ajouter, puis cliquez sur Nouvel élément.
Ajoutez un nouveau fichier de classe au projet, nommé WingtipClaimTypes.cs.

Le fichier WingtipClaimTypes.cs définit les types de revendications pris en charge par ce fournisseur de revendications. Remplacez le code dans le fichier WingtipClaimTypes.cs par le code suivant. Notez que nous avons ajouté un type de revendication, en l’occurrence « department ».

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

namespace WingtipClaimProvider
{
    public class WingtipClaimType
    {
        public static string EmailAddress = 
        "https://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress";
        public static string Title = 
        "http://schemas.wingtip.com/sharepoint/2009/08/claims/title";
        public static string Department = 
        "http://schemas.wingtip.com/sharepoint/2009/08/claims/department";
    }
}

Étape 2 : création de la classe WingtipUserInfo qui stocke les informations utilisateur et qui permet d’interroger les revendications utilisateur

Dans le projet, ajoutez un nouveau fichier de classe nommé WingtipUserInfo.cs, comme l’illustre la figure 2.

Figure 2. Ajout d’un nouveau fichier de classe au projet WingtipClaimProvider

Remplacez l’instruction using par le code suivant.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Administration;
using Microsoft.IdentityModel.Claims;
using System.Collections;

Ajoutez les deux tableaux de chaînes suivants à la classe WingtipUserInfo. Ces deux tableaux de chaînes font office de banque d’informations utilisateur.

Le tableau de chaînes userDB contient les informations utilisateur et les revendications associées. (L’adresse de messagerie est utilisée en guise d’identificateur de l’utilisateur.)
Le tableau de chaînes claimsDB contient les revendications disponibles pouvant être explorées par ce fournisseur de revendications.

        private static string[] userDB = 
           {
            "user1@wingtip.com:Email:user1@wingtip.com", 
            "user2@wingtip.com:Email:user1@wingtip.com", 
            "user3@wingtip.com:Email:user1@wingtip.com", 
            "user1@wingtip.com:Title:Engineer", 
            "user2@wingtip.com:Title:Manager", 
            "user3@wingtip.com:Title:CEO", 
            "user1@wingtip.com:Department:Finance", 
            "user2@wingtip.com:Department:IT", 
            "user3@wingtip.com:Department:AP", 
           };

        private static string[] claimsDB = 
           {
            "Email:user1@wingtip.com", 
            "Email:user2@wingtip.com",
            "Email:user3@wingtip.com",
            "Title:Employoee",
            "Title:Manager",
            "Title:NorthWest",
            "Department:Finance",
            "Department:IT",
            "Department:AP"
           };

Ajoutez le code suivant à la classe WingtipUserInfo. Ces fonctions sont simplement des fonctions utilitaires qui lisent et analysent les informations à partir des tableaux userDB et claimsDB. Elles sont utilisées pour la résolution, l’exploration et le recensement des revendications.

        /// <summary>
        /// A real-world implementation should look up a directory service 
        /// or database to retrieve a user claim.
        /// The following code is used only for demonstration purposes.
        /// </summary>
        /// <param name="username"></param>
        /// <returns></returns>
        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;
        }


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

            // Adding forms-based users.
            allUsers.Add("user1@wingtip.com");
            allUsers.Add("user2@wingtip.com");
            allUsers.Add("user3@wingtip.com");

            // Adding Windows domain users, if you want this provider to 
            // support Windows claims mode.
            return allUsers;
        }

        /// <summary>
        /// This function returns all the known claims from the CRM system 
        /// so that the claims provider is able to
        /// search and resolve the claims in the 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("Email", StringComparison.OrdinalIgnoreCase))
                return WingtipClaimType.EmailAddress;
            else if (roleName.Equals("Title", StringComparison.OrdinalIgnoreCase))
                return WingtipClaimType.Title;
            else if (roleName.Equals("Department", 
            StringComparison.OrdinalIgnoreCase))
                return WingtipClaimType.Department;
            else
                throw new Exception("Claim Type not found!");
        }

Étape 3 : ajout de code pour l’augmentation des revendications

Ajoutez un nouveau fichier de classe nommé ClaimProvider.cs.

Remplacez les instructions using par le code suivant.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Administration.Claims;
using Microsoft.SharePoint.Administration.Claims;
using Microsoft.SharePoint.WebControls;
using Microsoft.IdentityModel.Claims;

Modifiez l’héritage de classe en fonction du code suivant.
```
    class ClaimProvider: SPClaimProvider
```

Ajoutez un constructeur et deux propriétés.

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

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

        // The AssociatedTrustedLoginProviderName property is used for 
        // generating the SPClaim object. 
        public string AssociatedTrustedLoginProviderName
        {
            get { return "WingtipSTS";  }
        }

Ajoutez du code pour la prise en charge de l’augmentation, de l’exploration et de la résolution des revendications.

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

        /// <summary>
        /// Return true if you support claims resolve 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;
            }
        }

Ajoutez la fonction suivante pour fournir les informations Claim Types.

Notez que dans FillEntityTypes nous prenons en charge User et FormRoles. Vous devez retourner le type d’entité pour chaque type de revendication que vous prenez en charge. Dans ce cas, EmailAddress est traité comme une revendication d’identité (SPClaimEntityTypes.User), tandis que les deux autres types de revendication sont traités comme des rôles (SPClaimEntityTypes.FormRole).

        /// <summary>
        /// Returns all the claims types that are supported by this 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(WingtipClaimType.EmailAddress);
            claimTypes.Add(WingtipClaimType.Title);
            claimTypes.Add(WingtipClaimType.Department);
        }

        /// <summary>
        /// Return all claim value types that correspond to the claim types.
        /// You must return the values in the same order as 
        /// in FillClaimTypes(). 
        /// </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);
            claimValueTypes.Add
            (Microsoft.IdentityModel.Claims.ClaimValueTypes.String);
        }

        /// <summary>
        /// Required for the People Picker.
        /// 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.User);
            entityTypes.Add(SPClaimEntityTypes.FormsRole);
            entityTypes.Add(SPClaimEntityTypes.FormsRole);
        }

Ajoutez la fonction utilitaire suivante, qui permet de générer l’objet revendication.

Notes

Nous spécifions explicitement que l’émetteur de la revendication est WingtipSTS (pas WingtipClaimProvider).

        // The claim from this provider should have WingtipSTS as the 
        // provider name.
        private SPClaim CreateClaimForSTS(string claimtype, string claimValue)
        {

            SPClaim result = new SPClaim(claimtype,
                                        claimValue, 
                  Microsoft.IdentityModel.Claims.ClaimValueTypes.String, 
                  SPOriginalIssuers.Format
                                  (SPOriginalIssuerType.TrustedProvider, 
                                   AssociatedTrustedLoginProviderName));

            return result;
        }

Ajoutez la fonction FillClaimsForEntity pour prendre en charge l’augmentation des revendications.

      /// <summary>
        /// Implement this method if the 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");
            }

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

            //Adding claims for users.
            List<string> allWingtipUsers = WingtipUserInfo.GetAllUsers();

            if (allWingtipUsers.Contains(userIdClaim.Value.ToLower()))
            {
                List<Claim> userClaims = 
                WingtipUserInfo.GetClaimsForUser
                (userIdClaim.Value.ToLower());
                foreach (Claim claim in userClaims)
                {
                    claims.Add(CreateClaimForSTS(claim.ClaimType, claim.Value));
                }

            }

        }

Étape 4 : ajout de code pour l’exploration des revendications

Ajoutez la méthode FillSearch pour prendre en charge l’exploration des revendications.

Notez la partie en gras de la fonction. Lorsqu’un utilisateur recherche une adresse de messagerie, nous retournons la revendication d’identité ; sinon, nous retournons la revendication de rôle.

Notes

Nous utilisons une requête LINQ pour prendre en charge la recherche par caractères génériques dans ce cas.

       /// <summary>
        /// Required if you implement the claims search for 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 = WingtipUserInfo.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 for "SalesManager", 
                //the ClaimType will be CRMClaimType.Role.

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

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaimForSTS(claimType, claimValue);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = 
                claimValue;

                if (string.Compare(claimType, WingtipClaimType.EmailAddress, 
                true) == 0)
                {
                    entity.EntityType = SPClaimEntityTypes.User;
                }
                else
                {
                    entity.EntityType = SPClaimEntityTypes.FormsRole;
                }


                entity.IsResolved = true;
                searchTree.AddEntity(entity);
            }

        }

Étape 5 : ajout de code pour la résolution des revendications

Ajoutez les deux méthodes FillResolve pour prendre en charge la résolution des revendications.

Le code établit une correspondance entre le mot clé et les valeurs dans ClaimsDB, puis retourne les données appropriées.

      /// <summary>
        /// Resolve one single claim by using exact match. 
        /// This method is required for both claims search
        /// and claims 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 = WingtipUserInfo.GetAllClaims();

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

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaimForSTS(claimType, claimValue);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = 
                claimValue;
                if (string.Compare(claimType, WingtipClaimType.EmailAddress, true) 
                == 0)
                {
                    entity.EntityType = SPClaimEntityTypes.User;
                }
                else
                {
                    entity.EntityType = SPClaimEntityTypes.FormsRole;
                }

                entity.IsResolved = true;
                resolved.Add(entity);
            }
        }


        /// <summary>
        /// Required if you implement claims resolve for 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 = WingtipUserInfo.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 claim type.
                // For example, if you search for "SalesManager", 
                // the ClaimType will be CRMClaimType.Role.

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

                PickerEntity entity = CreatePickerEntity();
                entity.Claim = CreateClaimForSTS(claimType, claimValue);
                entity.Description = claimValue;
                entity.DisplayText = claimValue;
                entity.EntityData[PeopleEditorEntityDataKeys.DisplayName] = claimValue;
                if (string.Compare(claimType, WingtipClaimType.EmailAddress, 
                true) == 0)
                {
                    entity.EntityType = SPClaimEntityTypes.User;
                }
                else
                {
                    entity.EntityType = SPClaimEntityTypes.FormsRole;
                }
                entity.IsResolved = true;
                resolved.Add(entity);
            }

        }

Ajoutez la méthode FillHierarchy suivante qui montre que nous ne prenons pas en charge la hiérarchie.

       protected override void FillHierarchy(Uri context, string[] entityTypes, 
            string hierarchyNodeID, int numberOfLevels, SPProviderHierarchyTree hierarchy)
        {
            throw new NotImplementedException();
        }

Compilez le projet et corrigez les erreurs éventuelles.

Étape 6 : inscription du projet WingtipClaimProvider auprès de WingtipSTS

Pendant l’inscription, le nom du fournisseur de revendications doit correspondre au nom du fournisseur de connexions approuvé. En effet, la valeur de l’émetteur pour les revendications issues du fournisseur de connexions approuvé correspondra au nom de ce fournisseur de connexions approuvé. Pendant la sélection, si le fournisseur de revendications personnalisé porte un nom différent, les revendications ajoutées par ce fournisseur de revendications via le sélecteur de personnes possèdent une valeur issuer différente, ce qui entraînera une discordance pendant l’autorisation. Pour plus d’informations, voir Remplacement de la résolution de nom prête à l’emploi dans SharePoint 2010 : partie 2(éventuellement en anglais).

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud Fonctionnalités, puis cliquez sur Ajouter une fonctionnalité.
Définissez l’étendue de la fonctionnalité sur Farm.
Cliquez avec le bouton droit sur Feature1, puis cliquez sur Ajouter un récepteur d’événements.

Remplacez l’instruction using par le code suivant.

using System;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Security;
using Microsoft.SharePoint.Administration.Claims;

Modifiez l’héritage de classe en fonction du code suivant.

public class Feature1EventReceiver :SPClaimProviderFeatureReceiver

Ajoutez le code suivant à la classe. Laissez le reste du code commenté.

        private string providerDisplayName = "Wingtip Claim Provider";
        private string providerDescription = "Provides Claims from Wingtip";

        public override string ClaimProviderAssembly
        {
            get { return typeof
            (WingtipClaimProvider.ClaimProvider).Assembly.FullName; }
        }


        public override string ClaimProviderDisplayName
        {
            get
            {
                return providerDisplayName;
            }
        }

        public override string ClaimProviderType
        {
            get { return typeof(WingtipClaimProvider.ClaimProvider).FullName; }
        }

        public override string ClaimProviderDescription
        {
            get { return providerDescription; }
        }

        public override bool ClaimProviderUsedByDefault
        {
            get
            {
                return true;
            }
        }

Compilez le projet WingtipClaimProvider et assurez-vous qu’il est correctement généré.
Cliquez avec le bouton droit sur le projet WingtipClaimProvider, puis cliquez sur Déployer. Cette étape inscrit le fournisseur de revendications auprès de la batterie de serveurs.
Ouvrez Form1 dans le projet RegisterSTS.
Ajoutez un bouton nommé Update ClaimProvider.

Normalement, le formulaire ne comporte que deux boutons : l’un permet d’inscrire WingtipSTS, tandis que l’autre est nommé Update ClaimProvider, comme l’illustre la figure 3.

Figure 3. Formulaire1 avec bouton Update ClaimProvider

Dans le code-behind du nouveau bouton, ajoutez le code suivant.

            SPSecurityTokenServiceManager manager = SPSecurityTokenServiceManager.Local;

            string providerName = "WingtipSTS";

            SPTrustedLoginProvider provider = manager.TrustedLoginProviders[providerName];
            provider.ClaimProviderName = "WingtipClaimProvider";
            provider.Update();
        }

Compilez l’application et corrigez les erreurs éventuelles.
Cliquez avec le bouton droit sur le projet RegisterSTS, sélectionnez Déboguer, puis Démarrer une nouvelle instance.
Lorsque l’application démarre, cliquez sur le bouton Update ClaimProvider. Cette opération met à jour le fournisseur de revendications pour le fournisseur de connexions approuvé WingtipSTS.

Étape 7 : test du fournisseur de revendications

Assurez-vous que votre projet WingtipSTS est en cours d’exécution et qu’il est accessible via un navigateur.

Lancez le site Web Administration centrale.
Dans la page Créer une collection de sites (figure 4), sélectionnez https://intranet.contoso.com.

Figure 4. Page Créer une collection de sites
Dans la section Administrateur de la collection de sites, cliquez sur l’icône Parcourir pour lancer le sélecteur de personnes. Notez la présence d’un fournisseur de revendications Wingtip à gauche, comme l’illustre la figure 5. Il s’agit du fournisseur de revendications que vous venez de créer.

Figure 5. Fournisseur de revendications Wingtip tel qu’affiché dans le sélecteur de personnes
Dans le volet de gauche, sélectionnez Wingtip Claim Provider. Tapez user dans la zone Rechercher. Trois utilisateurs doivent être retournés, comme l’illustre la figure 6.

Figure 6. La recherche sur le terme « user » retourne trois utilisateurs dans le sélecteur de personnes
Sélectionnez User1@wingtip.com comme administrateur de collection de sites.
Créez la collection de sites sous https://intranet.contoso.com/sites/Test1.
Après avoir créé la collection de sites, dans votre navigateur, accédez à la page https://intranet.contoso.com/sites/Test1.
Dans la page d’ouverture de session de WingtipSTS, tapez les informations d’identification pour user1@wingtip.com (le mot de passe peut être toute chaîne de caractères), comme l’illustre la figure 7.

Notes

Assurez-vous que WingtipSTS est en cours d’exécution. Si ce n’est pas le cas, cliquez avec le bouton droit sur le projet WingtipSTS, puis sélectionnez Afficher dans le navigateur.

Figure 7. Page d’ouverture de session de WingtipSTS
Cliquez sur Envoyer. Vous devez être redirigé vers le site SharePoint. (Le premier lancement peut prendre un certain temps.)

Figure 8. Redirection vers le site SharePoint une fois la connexion réussie
Dans le menu Actions du site, sélectionnez Autorisations de site.
Dans le Ruban, cliquez sur Accorder des autorisations.
Tapez IT, puis appuyez sur la touche Entrée. Une fois le nom résolu, cliquez sur IT, puis sélectionnez it [Wingtip Claim Provider], comme l’illustre la figure 9.

Figure 9. Sélection de « it [Wingtip Claim Provider] »
Cliquez sur l’icône Parcourir pour ouvrir la boîte de dialogue Sélecteur de personnes.
Recherchez AP. Sélectionnez l’entrée retournée à partir de Wingtip Claim Provider, comme l’illustre la figure 10.

Figure 10. Sélection de AP de Wingtip Claim Provider
Ajoutez IT et AP au groupe Members (collaborateur), comme l’illustre la figure 11.

Figure 11. Ajout de « IT » et « AP » au groupe Membres (collaborateur)
Déconnectez-vous en tant qu’utilisateur user1@wingtip.com, comme l’illustre la figure 12, puis fermez toutes les instances de votre navigateur.

Notes

Cette étape est importante. Veillez à fermer toutes les instances de votre navigateur.

Figure 12. Déconnexion
Ouvrez une nouvelle instance d’Internet Explorer ou d’un autre navigateur, puis accédez à la page https://intranet.contoso.com/sites/Test1.
Essayez de vous connecter en utilisant user2@wingtip.com.
Pouvez-vous vous connecter ? Pourquoi ?
Essayez de vous connecter en utilisant user3@wingtip.com.
Pouvez-vous vous connecter ? Pourquoi ?
Créez un composant WebPart de visionneuse de revendication, puis ajoutez-le à la page d’accueil et affichez les revendications pour les trois utilisateurs. (Le code de cette étape n’est pas fourni.)

Conclusion

Dans cette procédure pas à pas, vous avez appris à créer un fournisseur de revendications pour un fournisseur de connexions approuvé. Un fournisseur de connexions approuvé est un service d’émission de jeton de sécurité externe approuvé par SharePoint.

Ressources supplémentaires

Pour plus d’informations, consultez les ressources suivantes :

Partager via

Procédure pas à pas sur les revendications : création de fournisseurs de revendications pour les fournisseurs de connexions approuvés pour SharePoint 2010

Vue d’ensemble de la création d’un fournisseur de revendications pour un fournisseur de connexions approuvé

Étape 1 : création du projet du fournisseur de revendications

Étape 2 : création de la classe WingtipUserInfo qui stocke les informations utilisateur et qui permet d’interroger les revendications utilisateur

Étape 3 : ajout de code pour l’augmentation des revendications

Étape 4 : ajout de code pour l’exploration des revendications

Étape 5 : ajout de code pour la résolution des revendications

Étape 6 : inscription du projet WingtipClaimProvider auprès de WingtipSTS

Étape 7 : test du fournisseur de revendications

Conclusion

Ressources supplémentaires

Ressources supplémentaires