ClaimsAuthorizationManager Klas

Definitie

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

Overname

Object

ClaimsAuthorizationManager

Implementeringen

ICustomIdentityConfiguration

Voorbeelden

De codevoorbeelden die in de ClaimsAuthorizationManager onderwerpen worden gebruikt, worden uit het Claims Based Authorization voorbeeld genomen. Dit voorbeeld biedt een aangepaste claimautorisatiebeheerder die onderwerpen kan autoriseren op basis van een beleid dat is opgegeven in de configuratie. De aangepaste claimautorisatiebeheer bestaat uit drie basisonderdelen: een klasse die is afgeleid van ClaimsAuthorizationManager die de manager implementeert, de ResourceAction klasse die een resource en een actie koppelt, en een beleidslezer die beleid leest en compileert dat is opgegeven in het configuratiebestand. Dit gecompileerde beleid kan vervolgens worden gebruikt door de claimautorisatiebeheerder om een principal te evalueren om toegang tot resources te autoriseren. Niet alle elementen worden omwille van de beknoptheid weergegeven. Zie de WIF-codevoorbeeldindex voor informatie over dit voorbeeld en andere voorbeelden die beschikbaar zijn voor WIF en waar u ze kunt downloaden.

De volgende code toont de implementatie van de aangepaste claimautorisatiemanager. De LoadCustomConfiguration methode leest en compileert het beleid vanuit de configuratie met behulp van de helperklasse van de beleidslezer (niet weergegeven) en de CheckAccess methode verleent of weigert toegang op basis van dit beleid.

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;
        }
    }
}

De volgende code toont de ResourceAction klasse die wordt gebruikt door de aangepaste claimbeheerder.

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;
        }
    }
}

In de volgende XML ziet u hoe u de claimautorisatiebeheer configureert die hierboven wordt weergegeven voor een webtoepassing die wordt gehost in IIS 7.5. Alleen de elementen die specifiek zijn voor de configuratie van de claimautorisatiebeheerder worden weergegeven. Houd er rekening mee dat een verwijzing naar de ClaimsAuthorizationModule klasse moet worden toegevoegd aan de pijplijn onder het <system.Webserver> element. Voor sites en toepassingen die worden gehost in versies van IIS vóór IIS 7, kunnen de modules worden toegevoegd aan de pijplijn onder het <system.Web> element. Deze configuratie wordt weergegeven, maar er is commentaar toegevoegd.

Het beleid dat wordt gebruikt door claimautorisatiebeheer, wordt opgegeven door aangepaste <policy> elementen onder het <element claimsAuthorizationManager> . In het eerste beleid moet de principal een van de opgegeven claims bezitten om de opgegeven actie uit te voeren op de opgegeven resource. In het tweede beleid moet de principal beide claims bezitten om de opgegeven actie op de opgegeven resource uit te voeren. In alle andere wordt de principal automatisch toegang verleend, ongeacht de claims die de principal bezit.

<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>

Opmerkingen

De ClaimsAuthorizationManager klasse biedt de basis-implementatie voor een claimautorisatiebeheerder. Een claimautorisatiebeheerder kan worden gebruikt in de volgende twee scenario's:

• In webtoepassingen en -services kan een claimautorisatiebeheerder worden toegevoegd aan de verwerkingspijplijn om een uitbreidbaarheidspunt te bieden waaruit u toegang tot een resource kunt autoriseren op basis van de waarde van binnenkomende claims voordat de toepassingscode die de aangevraagde resource daadwerkelijk implementeert, wordt aangeroepen.

• Wanneer u de ClaimsPrincipalPermission klasse of klasse ClaimsPrincipalPermissionAttribute gebruikt om imperatieve of declaratieve op claims gebaseerde toegangscontroles uit te voeren in uw code, wordt de claimautorisatiebeheerder die is geconfigureerd voor uw toepassing, aangeroepen door het systeem om de controle uit te voeren. Op claims gebaseerde toegangscontroles kunnen worden uitgevoerd in zowel webtoepassingen als desktoptoepassingen.

De standaard implementatie van de ClaimsAuthorizationManager klasse autoriseert de toegang voor elke gepresenteerde claim. U kunt echter afleiden van deze klasse en de CheckAccess methode overschrijven om uw eigen autorisatielogica te bieden.

Het gebruik van een claimautorisatiebeheerder is optioneel. U kunt uw toepassing configureren om programmatisch een claimautorisatiebeheer te gebruiken met behulp van de IdentityConfiguration klasse of declaratief, door het <element claimsAuthorizationManager> op te geven. Dit is een onderliggend element van het <element identityConfiguration> in uw toepassingsconfiguratiebestand. Als uw toepassing een website of een webtoepassing is die wordt gehost in Internet Information Services (IIS), moet u ook de ClaimsAuthorizationModule toevoegen in de verzameling http-modules van ASP.NET.

De ClaimsAuthorizationManager basisklasse neemt geen aanvullende configuratie in beslag. U kunt de LoadCustomConfiguration afgeleide klassen echter overschrijven om initialisatie van uw claimautorisatiebeheer te bieden van onderliggende elementen van de <claimsAuthorizationElement>. Het gebruikelijke scenario is om deze onderliggende elementen te gebruiken om autorisatiebeleid op te geven waarmee wordt bepaald welke claimtypen en -waarden vereist zijn om toegang te krijgen tot welke resource. Dit is geen harde vereiste, maar u bent vrij om te definiëren welk gebruik en welke syntaxis zinvol zijn voor uw implementatie.