ClaimsAuthorizationManager Klass

Definition

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

Arv

Object

ClaimsAuthorizationManager

Implementeringar

ICustomIdentityConfiguration

Exempel

Kodexemplen som används i ämnena ClaimsAuthorizationManager tas från Claims Based Authorization exemplet. Det här exemplet innehåller en ansvarig för anpassad anspråksauktorisering som kan auktorisera ämnen baserat på en princip som anges i konfigurationen. Hanteraren för anpassade anspråksauktorisering består av tre grundläggande komponenter: en klass som härleds från ClaimsAuthorizationManager som implementerar chefen, ResourceAction klassen som parar ihop en resurs och en åtgärd samt en principläsare som läser och kompilerar en princip som anges i konfigurationsfilen. Den här kompilerade principen kan sedan användas av anspråksauktoriseringshanteraren för att utvärdera ett huvudnamn för att auktorisera åtkomst till resurser. Alla element visas inte för korthetens skull. Information om det här exemplet och andra exempel som är tillgängliga för WIF och var du kan ladda ned dem finns i WIF Code Sample Index.

Följande kod visar implementeringen av hanteraren för anpassade anspråksauktorisering. Metoden LoadCustomConfiguration läser och kompilerar principen från konfigurationen med hjälp av hjälpklassen för principläsare (visas inte) och CheckAccess metoden beviljar eller nekar åtkomst baserat på den här principen.

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

Följande kod visar klassen ResourceAction som används av den anpassade anspråkshanteraren.

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

Följande XML visar hur du konfigurerar anspråksauktoriseringshanteraren som visas ovan för ett webbprogram som finns i IIS 7.5. Endast de element som är specifika för konfigurationen av anspråksauktoriseringshanteraren visas. Observera att en referens till ClaimsAuthorizationModule klassen måste läggas till i pipelinen under elementet <system.Webserver> . För webbplatser och program som finns i versioner av IIS före IIS 7 kan modulerna läggas till i pipelinen under elementet <system.Web> . Den här konfigurationen visas men kommenteras ut.

Principen som används av anspråksauktoriseringshanteraren anges av anpassade <policy> element under elementet< claimsAuthorizationManager>. I den första principen måste huvudkontot ha ett av de angivna anspråken för att kunna utföra den angivna åtgärden på den angivna resursen. I den andra principen måste huvudkontot ha båda anspråken för att kunna utföra den angivna åtgärden på den angivna resursen. I alla andra beviljas huvudmannen automatiskt åtkomst oavsett vilka anspråk det har.

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

Kommentarer

Klassen ClaimsAuthorizationManager tillhandahåller basimplementeringen för en anspråksauktoriseringshanterare. En hanterare för anspråksauktorisering kan användas i följande två scenarier:

• I webbaserade program och tjänster kan en hanterare för anspråksauktorisering läggas till i bearbetningspipelinen för att tillhandahålla en utökningspunkt från vilken du kan auktorisera åtkomst till en resurs enligt värdet för inkommande anspråk innan programkoden som faktiskt implementerar den begärda resursen anropas.

• När du använder ClaimsPrincipalPermission klassen eller ClaimsPrincipalPermissionAttribute klassen för att utföra antingen imperativa eller deklarativa anspråksbaserade åtkomstkontroller i koden anropas anspråksauktoriseringshanteraren som är konfigurerad för ditt program av systemet för att utföra kontrollen. Anspråksbaserade åtkomstkontroller kan utföras i både webbaserade program och skrivbordsprogram.

Standardimplementeringen som tillhandahålls av ClaimsAuthorizationManager klassen tillåter åtkomst för varje anspråk som visas. Du kan dock härleda från den CheckAccess här klassen och åsidosätta metoden för att tillhandahålla din egen auktoriseringslogik.

Det är valfritt att använda en hanterare för anspråksauktorisering. Du kan konfigurera programmet att använda en hanterare för anspråksauktorisering antingen programmatiskt med hjälp IdentityConfiguration av klassen eller deklarativt genom att ange elementet <claimsAuthorizationManager>, som är ett underordnat element i elementet< identityConfiguration> i programkonfigurationsfilen. Om ditt program är en webbplats eller ett webbprogram som finns i Internet Information Services (IIS) måste du också lägga till ClaimsAuthorizationModule i samlingen ASP.NET HTTP-moduler.

Basklassen ClaimsAuthorizationManager har ingen ytterligare konfiguration. Du kan dock åsidosätta LoadCustomConfiguration de härledda klasserna för att initiera din anspråksauktoriseringshanterare från underordnade element i <claimsAuthorizationElement>. Det vanliga scenariot är att använda dessa underordnade element för att ange auktoriseringsprinciper som avgör vilka anspråkstyper och värden som krävs för att få åtkomst till vilken resurs. Detta är inte ett svårt krav, men du kan definiera vilken användning och syntax som passar för implementeringen.