ClaimsAuthorizationManager Classe

Définition

public ref class ClaimsAuthorizationManager : System::IdentityModel::Configuration::ICustomIdentityConfiguration

public class ClaimsAuthorizationManager : System.IdentityModel.Configuration.ICustomIdentityConfiguration

type ClaimsAuthorizationManager = class
    interface ICustomIdentityConfiguration

Public Class ClaimsAuthorizationManager
Implements ICustomIdentityConfiguration

Héritage

Object

ClaimsAuthorizationManager

Implémente

ICustomIdentityConfiguration

Exemples

Les exemples de code utilisés dans les ClaimsAuthorizationManager rubriques sont tirés de l’exemple Claims Based Authorization . Cet exemple fournit un gestionnaire d’autorisation de revendications personnalisé qui peut autoriser des sujets en fonction d’une stratégie spécifiée dans la configuration. Le gestionnaire d’autorisation des revendications personnalisées se compose de trois composants de base : une classe dérivée de ClaimsAuthorizationManager qui implémente le gestionnaire, la ResourceAction classe qui associe une ressource et une action et un lecteur de stratégie qui lit et compile la stratégie spécifiée dans le fichier de configuration. Cette stratégie compilée peut ensuite être utilisée par le gestionnaire d’autorisation des revendications pour évaluer un principal afin d’autoriser l’accès aux ressources. Tous les éléments ne sont pas affichés par souci de concision. Pour plus d’informations sur cet exemple et d’autres exemples disponibles pour WIF et sur l’emplacement où les télécharger, consultez Index d’exemple de code WIF.

Le code suivant montre l’implémentation du gestionnaire d’autorisation des revendications personnalisées. La LoadCustomConfiguration méthode lit et compile la stratégie à partir de la configuration à l’aide de la classe d’assistance de lecteur de stratégie (non affichée) et la CheckAccess méthode accorde ou refuse l’accès en fonction de cette stratégie.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Xml;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Simple ClaimsAuthorizationManager implementation that reads policy information from the .config file
    /// </summary>
    public class MyClaimsAuthorizationManager : ClaimsAuthorizationManager
    {
        static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
        PolicyReader _policyReader = new PolicyReader();

        /// <summary>
        /// Creates a new instance of the MyClaimsAuthorizationManager
        /// </summary>        
        public MyClaimsAuthorizationManager()
        {
        }

        /// <summary>
        /// Overloads  the base class method to load the custom policies from the config file
        /// </summary>
        /// <param name="nodelist">XmlNodeList containing the policy information read from the config file</param>
        public override void LoadCustomConfiguration(XmlNodeList nodelist)
        {
            Expression<Func<ClaimsPrincipal, bool>> policyExpression;

            foreach (XmlNode node in nodelist)
            {
                //
                // Initialize the policy cache
                //
                XmlDictionaryReader rdr = XmlDictionaryReader.CreateDictionaryReader(new XmlTextReader(new StringReader(node.OuterXml)));
                rdr.MoveToContent();

                string resource = rdr.GetAttribute("resource");
                string action = rdr.GetAttribute("action");

                policyExpression = _policyReader.ReadPolicy(rdr);

                //
                // Compile the policy expression into a function
                //
                Func<ClaimsPrincipal, bool> policy = policyExpression.Compile();

                //
                // Insert the policy function into the policy cache
                //
                _policies[new ResourceAction(resource, action)] = policy;
            }
        }

        /// <summary>
        /// Checks if the principal specified in the authorization context is authorized to perform action specified in the authorization context 
        /// on the specified resoure
        /// </summary>
        /// <param name="pec">Authorization context</param>
        /// <returns>true if authorized, false otherwise</returns>
        public override bool CheckAccess(AuthorizationContext pec)
        {
            //
            // Evaluate the policy against the claims of the 
            // principal to determine access
            //
            bool access = false;
            try
            {
                ResourceAction ra = new ResourceAction(pec.Resource.First<Claim>().Value, pec.Action.First<Claim>().Value);

                access = _policies[ra](pec.Principal);
            }
            catch (Exception)
            {
                access = false;
            }

            return access;
        }
    }
}

Le code suivant montre la ResourceAction classe utilisée par le gestionnaire de revendications personnalisé.

using System;

namespace ClaimsAuthorizationLibrary
{
    /// <summary>
    /// Class to encapsulate resource/action pair
    /// </summary>
    public class ResourceAction
    {
        public string Resource;
        public string Action;

        /// <summary>
        /// Checks if the current instance is equal to the given object by comparing the resource and action values
        /// </summary>
        /// <param name="obj">object to compare to</param>
        /// <returns>True if equal, else false.</returns>
        public override bool Equals(object obj)
        {
            ResourceAction ra = obj as ResourceAction;
            if (ra != null)
            {
                return ((string.Compare(ra.Resource, Resource, true) == 0) && (string.Compare(ra.Action, Action, true) == 0));
            }

            return base.Equals(obj);
        }

        /// <summary>
        /// Gets the hash code.
        /// </summary>
        /// <returns>The hash code.</returns>
        public override int GetHashCode()
        {
            return (Resource + Action).ToLower().GetHashCode();
        }

        /// <summary>
        /// Creates an instance of ResourceAction class.
        /// </summary>
        /// <param name="resource">The resource name.</param>
        /// <param name="action">The action.</param>
        /// <exception cref="ArgumentNullException">when <paramref name="resource"/> is null</exception>
        public ResourceAction(string resource, string action)
        {
            if (string.IsNullOrEmpty(resource))
            {
                throw new ArgumentNullException("resource");
            }

            Resource = resource;
            Action = action;
        }
    }
}

Le code XML suivant montre comment configurer le gestionnaire d’autorisation des revendications indiqué ci-dessus pour une application web hébergée dans IIS 7.5. Seuls les éléments spécifiques à la configuration du gestionnaire d’autorisation des revendications sont affichés. Notez qu’une référence à la ClaimsAuthorizationModule classe doit être ajoutée au pipeline sous l’élément <system.Webserver> . Pour les sites et applications hébergés dans des versions d’IIS antérieures à IIS 7, les modules peuvent être ajoutés au pipeline sous l’élément <system.Web> . Cette configuration est affichée, mais commentée.

La stratégie utilisée par le gestionnaire d’autorisation des revendications est spécifiée par les éléments personnalisés <policy> sous l’élément <claimsAuthorizationManager> . Dans la première stratégie, le principal doit posséder l’une des revendications spécifiées pour effectuer l’action spécifiée sur la ressource spécifiée. Dans la deuxième stratégie, le principal doit posséder les deux revendications pour pouvoir effectuer l’action spécifiée sur la ressource spécifiée. Dans tous les autres cas, l’accès au principal est automatiquement accordé, quelles que soient les revendications qu’il possède.

<configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type="ClaimsAuthorizationLibrary.MyClaimsAuthorizationManager, ClaimsAuthorizationLibrary">
        <policy resource="http://localhost:28491/Developers.aspx" action="GET">
          <or>
            <claim claimType="http://schemas.microsoft.com/ws/2008/06/identity/claims/role" claimValue="developer" />
            <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
          </or>
        </policy>
        <policy resource="http://localhost:28491/Administrators.aspx" action="GET">
          <and>
            <claim claimType="http://schemas.xmlsoap.org/claims/Group" claimValue="Administrator" />
            <claim claimType="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country" claimValue="USA" />
          </and>
        </policy>
        <policy resource="http://localhost:28491/Default.aspx" action="GET">
        </policy>
        <policy resource="http://localhost:28491/" action="GET">
        </policy>
        <policy resource="http://localhost:28491/Claims.aspx" action="GET">
        </policy>
      </claimsAuthorizationManager>

      ...

    </identityConfiguration>
  </system.identityModel>
  ...

</configuration><configuration>
  <configSections>
    <!--WIF 4.5 sections -->
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
    ...

  </configSections>

  ...

  <system.web>
    <httpModules>
      <!--WIF 4.5 modules -->
      <!--Not needed here for IIS >= 7 -->
      <!--<add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>-->
    </httpModules>
  </system.web>

  ...

  <system.webServer>
    <modules>
      <!--WIF 4.5 modules -->
      <add name="ClaimsAuthorizationModule" type="System.IdentityModel.Services.ClaimsAuthorizationModule, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </modules>
  </system.webServer>

  ...

  <!-- WIF 4.5 s.im section-->
  <system.identityModel>
    <identityConfiguration>
      <claimsAuthorizationManager type="MyClaimsAuthorizationManager.SimpleClaimsAuthorizationManager, MyClaimsAuthorizationManager" />
      ...

  </system.identityModel>
  ...

</configuration>

Remarques

La ClaimsAuthorizationManager classe fournit l’implémentation de base pour un gestionnaire d’autorisation de revendications. Un gestionnaire d’autorisation de revendications peut être utilisé dans les deux scénarios suivants :

• Dans les applications et services web, un gestionnaire d’autorisation de revendications peut être ajouté au pipeline de traitement pour fournir un point d’extensibilité à partir duquel vous pouvez autoriser l’accès à une ressource en fonction de la valeur des revendications entrantes avant que le code d’application qui implémente réellement la ressource demandée soit appelé.

• Lorsque vous utilisez la ClaimsPrincipalPermission classe ou la ClaimsPrincipalPermissionAttribute classe pour effectuer des vérifications d’accès impératives ou déclaratives basées sur les revendications dans votre code, le gestionnaire d’autorisation des revendications configuré pour votre application est appelé par le système pour effectuer la vérification. Les vérifications d’accès basées sur les revendications peuvent être effectuées dans les applications web et les applications de bureau.

L’implémentation par défaut fournie par la classe autorise l’accès ClaimsAuthorizationManager pour chaque revendication présentée. Toutefois, vous pouvez dériver de cette classe et remplacer la CheckAccess méthode pour fournir votre propre logique d’autorisation.

L’utilisation d’un gestionnaire d’autorisation de revendications est facultative. Vous pouvez configurer votre application pour utiliser un gestionnaire d’autorisation de revendications par programmation à l’aide de la IdentityConfiguration classe ou de manière déclarative, en spécifiant l’élément <claimsAuthorizationManager> , qui est un élément enfant de l’élément <identityConfiguration> dans votre fichier de configuration d’application. Si votre application est un site web ou une application web hébergée dans Internet Information Services (IIS), vous devez également ajouter le ClaimsAuthorizationModule dans la collection modules HTTP ASP.NET.

La ClaimsAuthorizationManager classe de base ne prend aucune configuration supplémentaire. Toutefois, vous pouvez remplacer dans les classes dérivées pour fournir l’initialisation LoadCustomConfiguration de votre gestionnaire d’autorisation de revendications à partir d’éléments enfants du <claimsAuthorizationElement>. Le scénario classique consiste à utiliser ces éléments enfants pour spécifier des stratégies d’autorisation qui déterminent les types et valeurs de revendication requis pour accéder à quelle ressource. Il ne s’agit pas d’une exigence stricte, bien que vous soyez libre de définir l’utilisation et la syntaxe qui ont un sens pour votre implémentation.

Constructeurs

Méthodes

S’applique à