ClaimsAuthorizationManager Classe

Definição

Define a implementação de base para um gerenciador de autorização de declarações.Defines the base implementation for a claims authorization manager.

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
ClaimsAuthorizationManager
Implementações

Exemplos

Os exemplos de código que são usados nos ClaimsAuthorizationManager Tópicos são extraídos do Claims Based Authorization exemplo.The code examples that are used in the ClaimsAuthorizationManager topics are taken from the Claims Based Authorization sample. 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.This sample provides a custom claims authorization manager that can authorize subjects based on a policy that is specified in configuration. O Gerenciador de autorização de declarações personalizado consiste em três componentes básicos: uma classe derivada de ClaimsAuthorizationManager que implementa o gerente, 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.The custom claims authorization manager consists of three basic components: a class derived from ClaimsAuthorizationManager that implements the manager, the ResourceAction class that pairs a resource and an action, and a policy reader that reads and compiles policy that is specified in the configuration file. Essa política compilada pode ser usada pelo Gerenciador de autorização de declarações para avaliar uma entidade de segurança a fim de autorizar o acesso aos recursos.This compiled policy can then be used by the claims authorization manager to evaluate a principal in order to authorize access to resources. Nem todos os elementos são mostrados para fins de brevidade.Not all elements are shown for the sake of brevity. Para obter informações sobre esse exemplo e outros exemplos disponíveis para o WIF e sobre onde baixá-los, consulte o índice de exemplo de código do WIF.For information about this sample and other samples available for WIF and about where to download them, see WIF Code Sample Index.

O código a seguir mostra a implementação do Gerenciador de autorização de declarações personalizado.The following code shows the implementation of the custom claims authorization manager. O LoadCustomConfiguration método lê e compila a política da configuração usando a classe auxiliar do leitor de política (não mostrada) e o CheckAccess método concede ou nega o acesso com base nessa política.The LoadCustomConfiguration method reads and compiles the policy from configuration by using the policy reader helper class (not shown) and the CheckAccess method grants or denies access based on this policy.

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.The following code shows the ResourceAction class used by the custom claims manager.


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.The following XML shows how to configure the claims authorization manager shown above for a web application hosted in IIS 7.5. Somente os elementos específicos da configuração do Gerenciador de autorização de declarações são mostrados.Only the elements specific to the configuration of the claims authorization manager are shown. Observe que uma referência à ClaimsAuthorizationModule classe deve ser adicionada ao pipeline sob o <system.Webserver> elemento.Note that a reference to the ClaimsAuthorizationModule class must be added to the pipeline under the <system.Webserver> element. Para sites e aplicativos hospedados em versões do IIS anteriores ao IIS 7, os módulos podem ser adicionados ao pipeline sob o <system.Web> elemento.For sites and applications hosted in versions of IIS prior to IIS 7 the modules can be added to the pipeline under the <system.Web> element. Essa configuração é mostrada, mas comentada.This configuration is shown but commented out.

A política usada pelo Gerenciador de autorização de declarações é especificada por <policy> elementos personalizados sob o elemento < ClaimsAuthorizationManager > .The policy used by the claims authorization manager is specified by custom <policy> elements under the <claimsAuthorizationManager> element. Na primeira política, a entidade de segurança deve ter uma das declarações especificadas para executar a ação especificada no recurso especificado.In the first policy, the principal must possess one of the specified claims in order to perform the specified action on the specified resource. Na segunda política, a entidade de segurança deve ter ambas as declarações para poder executar a ação especificada no recurso especificado.In the second policy, the principal must possess both claims to be able to perform the specified action on the specified resource. Em todos os outros, a entidade de segurança recebe automaticamente o acesso, independentemente das declarações que ele possui.In all others, the principal is automatically granted access regardless of the claims it possesses.

<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.The ClaimsAuthorizationManager class provides the base implementation for a claims authorization manager. Um Gerenciador de autorização de declarações pode ser usado nos dois cenários a seguir:A claims authorization manager can be used in the following two scenarios:

  • 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.In web-based applications and services, a claims authorization manager can be added to the processing pipeline to provide an extensibility point from which you can authorize access to a resource according to the value of incoming claims before the application code that actually implements the requested resource is called.

  • Quando você usa a ClaimsPrincipalPermission classe ou a ClaimsPrincipalPermissionAttribute classe para executar verificações de acesso com base em declarações imperativas ou declarativas em seu código, o Gerenciador de autorização de declarações configurado para seu aplicativo é chamado pelo sistema para executar a verificação.When you use the ClaimsPrincipalPermission class or the ClaimsPrincipalPermissionAttribute class to perform either imperative or declarative claims-based access checks in your code, the claims authorization manager that is configured for your application is called by the system to perform the check. As verificações de acesso baseadas em declarações podem ser executadas em aplicativos baseados na Web e em aplicativos da área de trabalho.Claims-based access checks can be performed in both web-based applications and desktop applications.

A implementação padrão fornecida pela ClaimsAuthorizationManager classe autoriza o 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.The default implementation provided by the ClaimsAuthorizationManager class authorizes access for each claim presented; however, you can derive from this class and override the CheckAccess method to provide your own authorization logic.

O uso de um Gerenciador de autorização de declarações é opcional.The use of a claims authorization manager is optional. 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.You can configure your application to use a claims authorization manager either programmatically by using the IdentityConfiguration class or declaratively, by specifying the <claimsAuthorizationManager> element, which is a child element of the <identityConfiguration> element in your application configuration file. Se seu aplicativo for um site da Web ou um aplicativo Web hospedado no Serviços de Informações da Internet (IIS), você também deverá adicionar o ClaimsAuthorizationModule na coleção de módulos HTTP ASP.net.If your application is a web site or a web application hosted in Internet Information Services (IIS), you must also add the ClaimsAuthorizationModule in the ASP.NET HTTP Modules collection.

Importante

Quando você usa a ClaimsPrincipalPermission classe ou a ClaimsPrincipalPermissionAttribute classe, o Gerenciador de autorização de declarações que é usado para executar a verificação de acesso é aquele especificado na configuração de identidade na FederatedAuthentication.FederationConfiguration propriedade.When you use the ClaimsPrincipalPermission class or the ClaimsPrincipalPermissionAttribute class, the claims authorization manager that is used to perform the access check is the one that is specified in the identity configuration under the FederatedAuthentication.FederationConfiguration property. Em um arquivo de configuração, é a <identityConfiguration> seção que é referenciada do <federationConfiguration> elemento padrão.In a configuration file, it is the <identityConfiguration> section that is referenced from the default <federationConfiguration> element. Isso é verdadeiro mesmo para aplicativos de área de trabalho e serviços de Windows Communication Foundation (WCF).This is true even for Windows Communication Foundation (WCF) services and desktop applications.

A ClaimsAuthorizationManager classe base não precisa de nenhuma configuração adicional; no entanto, você pode substituir as LoadCustomConfiguration classes derivadas no para fornecer a inicialização do Gerenciador de autorização de declarações dos elementos filho do <claimsAuthorizationElement> .The ClaimsAuthorizationManager base class does not take any additional configuration; however, you can override the LoadCustomConfiguration in derived classes to provide initialization of your claims authorization manager from child elements of the <claimsAuthorizationElement>. O cenário típico é usar esses elementos filho para especificar políticas de autorização que determinam quais tipos e valores de declaração são necessários para obter acesso a qual recurso.The typical scenario is to use these child elements to specify authorization policies which determine which claim types and values are required in order to gain access to which resource. Isso não é um requisito difícil, embora você esteja livre para definir qualquer uso e sintaxe que façam sentido para sua implementação.This is not a hard requirement, though you are free to define whatever usage and syntax make sense for your implementation.

Construtores

ClaimsAuthorizationManager()

Inicializa uma nova instância da classe ClaimsAuthorizationManager.Initializes a new instance of the ClaimsAuthorizationManager class.

Métodos

CheckAccess(AuthorizationContext)

Quando implementado em uma classe derivada, verifica a entidade na autorização no contexto especificado para executar a ação especificada no recurso especificado.When implemented in a derived class, checks authorization for the subject in the specified context to perform the specified action on the specified resource.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
LoadCustomConfiguration(XmlNodeList)

Quando substituído em uma classe derivada, carrega a configuração personalizada do XML.When overridden in a derived class, loads custom configuration from XML.

MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Aplica-se a