ClaimsAuthorizationManager Classe

Definição

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

Herança

Object

ClaimsAuthorizationManager

Implementações

ICustomIdentityConfiguration

Exemplos

Os exemplos de código usados nos ClaimsAuthorizationManager tópicos são obtidos do Claims Based Authorization exemplo. Este exemplo fornece um gerenciador de autorização de declarações personalizado que pode autorizar assuntos com base em uma política especificada na configuração. O gerenciador de autorização de declarações personalizadas consiste em três componentes básicos: uma classe derivada de ClaimsAuthorizationManager que implementa o gerenciador, a ResourceAction classe que emparelha um recurso e uma ação e um leitor de política que lê e compila a política especificada no arquivo de configuração. Essa política compilada pode ser usada pelo gerenciador de autorização de declarações para avaliar uma entidade de segurança para autorizar o acesso aos recursos. Nem todos os elementos são mostrados por questão de brevidade. Para obter informações sobre este exemplo e outros exemplos disponíveis para WIF e sobre onde baixá-los, consulte Índice de exemplo de código WIF.

O código a seguir mostra a implementação do gerenciador de autorização de declarações personalizadas. O LoadCustomConfiguration método lê e compila a política a partir da configuração usando a classe auxiliar de leitor de política (não mostrada) e o CheckAccess método concede ou nega acesso com base nessa política.

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

O código a seguir mostra a ResourceAction classe usada pelo gerenciador de declarações personalizado.

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

O XML a seguir mostra como configurar o gerenciador de autorização de declarações mostrado acima para um aplicativo Web hospedado no IIS 7.5. Somente os elementos específicos para a configuração do gerenciador de autorização de declarações são mostrados. Observe que uma referência à ClaimsAuthorizationModule classe deve ser adicionada ao pipeline sob o <system.Webserver> elemento . Para sites e aplicativos hospedados em versões do IIS antes do IIS 7, os módulos podem ser adicionados ao pipeline sob o <system.Web> elemento . Essa configuração é mostrada, mas comentada.

A política usada pelo gerenciador de autorização de declarações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Na primeira política, a entidade de segurança deve possuir uma das declarações especificadas para executar a ação especificada no recurso especificado. Na segunda política, a entidade de segurança deve possuir ambas as declarações para poder executar a ação especificada no recurso especificado. Em todos os outros, a entidade de segurança recebe automaticamente acesso, independentemente das declarações que possui.

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

Comentários

A ClaimsAuthorizationManager classe fornece a implementação base para um gerenciador de autorização de declarações. Um gerenciador de autorização de declarações pode ser usado nos dois cenários a seguir:

• Em aplicativos e serviços baseados na Web, um gerenciador de autorização de declarações pode ser adicionado ao pipeline de processamento para fornecer um ponto de extensibilidade do qual você pode autorizar o acesso a um recurso de acordo com o valor das declarações de entrada antes que o código do aplicativo que realmente implementa o recurso solicitado seja chamado.

• Quando você usa a ClaimsPrincipalPermission classe ou a ClaimsPrincipalPermissionAttribute classe para executar verificações de acesso imperativas ou declarativas baseadas em declarações em seu código, o gerenciador de autorização de declarações configurado para seu aplicativo é chamado pelo sistema para executar a verificação. As verificações de acesso baseadas em declarações podem ser executadas em aplicativos baseados na Web e em aplicativos da área de trabalho.

A implementação padrão fornecida pela classe autoriza o ClaimsAuthorizationManager acesso para cada declaração apresentada; no entanto, você pode derivar dessa classe e substituir o CheckAccess método para fornecer sua própria lógica de autorização.

O uso de um gerenciador de autorização de declarações é opcional. Você pode configurar seu aplicativo para usar um gerenciador de autorização de declarações programaticamente usando a IdentityConfiguration classe ou declarativamente, especificando o <elemento claimsAuthorizationManager> , que é um elemento filho do <elemento identityConfiguration> no arquivo de configuração do aplicativo. Se seu aplicativo for um site ou um aplicativo Web hospedado nos Serviços de Informações da Internet (IIS), você também deverá adicionar o ClaimsAuthorizationModule na coleção ASP.NET módulos HTTP.

A ClaimsAuthorizationManager classe base não usa nenhuma configuração adicional; no entanto, você pode substituir o LoadCustomConfiguration em classes derivadas para fornecer a inicialização do gerenciador de autorização de declarações de elementos filho do <claimsAuthorizationElement>. O cenário típico é usar esses elementos filho para especificar políticas de autorização que determinam quais tipos de declaração e valores são necessários para obter acesso a qual recurso. Esse não é um requisito difícil, embora você esteja livre para definir qualquer uso e sintaxe que façam sentido para sua implementação.

Construtores

Métodos

Aplica-se a