Cette section a été ajoutée par le traducteur.

Pour citer la documentation MSDN :

Windows® Identity Foundation (WIF) est une infrastructure pour la génération d'applications prenant en charge les identités. L'infrastructure rend les protocoles WS-Trust et WS-Federation abstraits et présente aux développeurs des API pour la génération de services d'émission de jeton de sécurité (STS) et d'applications prenant en charge les revendications. Les applications peuvent utiliser WIF pour traiter les jetons émis à partir de services d'émission de jeton de sécurité et prendre des décisions basées sur l'identité au niveau de l'application Web ou du service Web.

WIF présente les principales fonctionnalités suivantes :

• Génération d'applications prenant en charge les revendications (applications de partie de confiance). WIF aide les développeurs à générer des applications prenant en charge les revendications. En plus de fournir un nouveau modèle de revendications, il fournit aux développeurs d'applications un jeu riche d'API pour aider à prendre des décisions concernant l'accès utilisateur en fonction des revendications. WIF fournit également aux développeurs une expérience de programmation cohérente, qu'ils choisissent de générer leurs applications dans des environnements ASP.NET ou WCF.
• WIF offre des modèles Visual Studio intégrés pour les applications de site Web ASP.NET et de service Web WCF prenant en charge les revendications et réduit la durée d'apprentissage du modèle de programmation basé sur les revendications.
• Facilité d'établissement d'approbation entre une application prenant en charge les revendications et un STS. WIF fournit un utilitaire, nommé FedUtil, pour faciliter l'établissement d'approbation entre les applications prenant en charge les revendications et un STS, tel qu'Active Directory Federation Services 2.0 et un STS LiveID. FedUtil prend en charge les applications ASP.NET et WCF. Il est également intégré à Visual Studio pour pouvoir être appelé depuis l'Explorateur de solutions, en effectuant un clic droit sur un projet et en choisissant l'élément de menu « Ajouter référence STS », ou depuis le menu « Outils » de Visual Studio.
• Les contrôles ASP.NET qui simplifient le développement de pages ASP.NET pour la génération d'applications Web prenant en charge les revendications.
• La traduction entre revendications et jetons NT. WIF inclut un service Windows nommé qui joue le rôle de pont entre les applications prenant en charge les revendications et les applications basées sur une autorisation de jeton Windows NT. Il fournit aux développeurs une méthode simple de conversion des revendications en identité de jeton NT et permet d'accéder aux ressources qui requièrent l'identité basée sur une autorisation de jeton Windows NT d'une application prenant en charge les revendications.
• Prise en charge de la génération de délégation d'identité dans les applications prenant en charge les revendications. WIF permet d'effectuer la maintenance des identités des demandeurs d'origine dans les différents services. Cette capacité résulte de l'utilisation de la fonctionnalité « ActAs » ou « OnBehalfOf » dans l'infrastructure et permet aux développeurs d'ajouter la prise en charge de la délégation d'identité à leurs applications prenant en charge les revendications.
• Génération de services d'émission de jeton de sécurité personnalisés. WIF simplifie considérablement la génération d'un service d'émission de jeton de sécurité personnalisé qui prend en charge le protocole WS-Trust. Un tel STS est également appelé « STS actif ». De plus, l'infrastructure fournit également la prise en charge pour la génération d'un STS qui prend en charge WS-Federation pour activer les clients de navigateur Web. Un tel STS est également appelé « STS passif ».
  L'infrastructure offre des modèles Visual Studio intégrés pour la génération de STS ASP.NET et STS WCF ; ces modèles créent des STS simples et les développeurs peuvent étendre ces derniers et implémenter des STS de production adaptés à leurs besoins.

WIF prend en charge les principaux scénarios de fédération suivants :

• Fédération : WIF permet de générer la fédération entre plusieurs partenaires. Sa prise en charge de la génération d'applications prenant en charge les revendications (RP) et de services d'émission de jeton de sécurité (STS) personnalisés aide les développeurs à accomplir ce scénario.
• Délégation d'identité : WIF facilite la conservation des identités à travers les services afin que les développeurs puissent réaliser un scénario de délégation d'identité.
• Authentification à un niveau supérieur : Les exigences en matière d'authentification pour les différentes ressources d'une application peuvent varier. WIF fournit aux développeurs la capacité de générer des applications qui peuvent requérir des exigences d'authentification incrémentielles (par exemple, l'ouverture de session initiale avec une authentification par nom d'utilisateur/mot de passe, puis l'authentification au niveau supérieur par carte à puce).

En utilisant WIF, vous pourrez profiter plus facilement des avantages du modèle d'identité basé sur les revendications.

Windows Identity Foundation (WIF) peut, ainsi, être utilisé pour déterminer l'identité de l'appelant depuis un service Web.

L'exemple présenté dans cet article affine celui présenté dans l'article précédent de la série, afin d'illustrer la détermination de l'identité de l'appelant. Lors de chaque appel au service Web, l'identité de l'utilisateur qui appelle le service Web est ajouté dans un fichier journal. Ce fichier journal peut ensuite être consulté pour connaître l'identité de l'appelant.

1. La première étape est de télécharger et d'installer Windows Identity Foundation. Installez WIF sur l'ordinateur sur lequel vous avez créé le service Web WCF.
2. Pour compiler le service Web, ouvrez le projet que vous avez créé dans le premier article de la série, Prise en main de la création d'un service Web WCF.
3. Ajoutez une référence à l'assembly Microsoft.IdentityModel. Dans Visual Studio, cliquez sur Projet > Ajouter une référence. Cliquez sur l'onglet Parcourir. Accédez à %ProgramFiles%\Reference Assemblies\Microsoft\Windows Identity Foundation\v3.5.

   

4. Sélectionnez Microsoft.IdentityModel.dll, puis cliquez sur OK.

   

5. Remplacez le contenu de Customers.svc.cs par le code suivant.
    

   Sélectionnez

   using System;
   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
   using Microsoft.IdentityModel.Claims;
   
   namespace CustomersService
   {
       public class Customers : ICustomers
       {
           private const string IdentityClaimType = @"http://schemas.microsoft.com/sharepoint/2009/08/claims/userid";
   
           private string GetIdentity()
           {
               string identityName = String.Empty;
               IClaimsIdentity claimsIdentity = System.Threading.Thread.CurrentPrincipal.Identity as IClaimsIdentity;
               if (claimsIdentity != null)
               {
                   // claim
                   foreach (Claim claim in claimsIdentity.Claims)
                   {
                       if (String.Equals(IdentityClaimType, claim.ClaimType, StringComparison.OrdinalIgnoreCase))
                       {
                           identityName = claim.Value;
                           break;
                       }
                   }
               }
               else
               {
                   identityName = System.Threading.Thread.CurrentPrincipal.Identity.Name;
               }
   
               return identityName;
           }
   
           // Finder
           public List<Customer> GetAllCustomers()
           {
               string id = GetIdentity();
               File.AppendAllText(@"C:\MyWebService\log.txt", string.Format("GetAllCustomers: Identity: {0}", id) + Environment.NewLine);
               return new List<Customer>()
               {
                   new Customer
                   {
                       CustomerID = 1,
                       CustomerName = "Bob",
                   },
                   new Customer
                   {
                       CustomerID = 2,
                       CustomerName = "Bill",
                   },
                   new Customer
                   {
                       CustomerID = 3,
                       CustomerName = "Cheryl",
                   },
               };
           }
   
           // Specific finder
           public Customer GetCustomerByID(int CustomerID)
           {
               string id = GetIdentity();
               File.AppendAllText(@"C:\MyWebService\log.txt", string.Format("GetCustomerByID: Identity: {0}", id) + Environment.NewLine);
               return GetAllCustomers().FirstOrDefault(c => c.CustomerID == CustomerID);
           }
       }
   }
   

6. Recompilez l'application. Étant donné qu'elle est hébergée en utilisant IIS, nous n'avons rien à faire pour que le service recompilé soit actif.
7. Utilisez wcftestclient pour « entrainer » le service Web.
   Démarrez une invite de commandes de Visual Studio. Tapez wcftestclient pour exécuter le client test WCF. Cliquez sur Fichier > Ajouter un service. Saisissez http://localhost/Customers/Customers.svc comme adresse du point de terminaison, puis cliquez sur OK.

   

   Si le service a été ajouté avec succès, vous allez voir les méthodes que le service expose.

   

   Double-cliquez sur GetAllCustomers. Cela ouvre une fenêtre qui vous permet de configurer et d'appeler la requête. Cliquez sur Appeler pour que GetAllCustomers soit appelée.

   

   Après avoir appelé le service Web, naviguez à C:\MyWebService et examinez log.txt. Le fichier journal ressemblera à quelque chose comme ceci :
   GetAllCustomers: Identity: CONTOSO\ericwhite