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 retirados da Claims Based Authorization amostra. Este exemplo fornece um gestor personalizado de autorização de reclamações que pode autorizar os sujeitos com base numa política especificada na configuração. O gestor personalizado de autorização de reivindicações consiste em três componentes básicos: uma classe derivada de ClaimsAuthorizationManager que implementa o gestor, a ResourceAction classe que emparelha um recurso e uma ação, e um leitor de políticas que lê e compila a política especificada no ficheiro de configuração. Esta apólice compilada pode depois ser usada pelo gestor de autorização de sinistros para avaliar um principal e autorizar o acesso aos recursos. Nem todos os elementos são mostrados por brevidade. Para informações sobre esta amostra e outras amostras disponíveis para WIF e sobre onde as descarregar, consulte o Índice de Exemplos de Código WIF.

O código seguinte mostra a implementação do gestor personalizado de autorização de sinistros. O LoadCustomConfiguration método lê e compila a política a partir da configuração usando a classe assistente do leitor de políticas (não mostrada) e o CheckAccess método concede ou recusa o acesso com base nesta 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 seguinte mostra a ResourceAction classe usada pelo gestor personalizado de sinistros.

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 seguinte mostra como configurar o gestor de autorização de reclamações mostrado acima para uma aplicação web alojada no IIS 7.5. Apenas os elementos específicos da configuração do gestor de autorização de reclamações são apresentados. Note que uma referência à ClaimsAuthorizationModule classe deve ser adicionada ao pipeline sob o <system.Webserver> elemento. Para sites e aplicações alojadas em versões do IIS anteriores ao IIS 7, os módulos podem ser adicionados ao pipeline sob o <system.Web> elemento. Esta configuração é mostrada, mas comentada.

A apólice utilizada pelo gestor de autorização de reclamações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Na primeira apólice, o principal deve possuir uma das reivindicações especificadas para realizar a ação especificada sobre o recurso especificado. Na segunda apólice, o principal deve possuir ambas as reivindicações para poder realizar a ação especificada sobre o recurso especificado. Em todas as outras, o principal recebe acesso automaticamente independentemente das reivindicaçõ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>

Observações

A ClaimsAuthorizationManager classe fornece a implementação base para um gestor de autorização de sinistros. Um gestor de autorização de sinistros pode ser utilizado nos seguintes dois cenários:

• Em aplicações e serviços baseados na web, pode ser adicionado um gestor de autorização de reclamações ao pipeline de processamento para fornecer um ponto de extensibilidade a partir do qual pode autorizar o acesso a um recurso de acordo com o valor das reclamações recebidas, antes de ser chamado o código da aplicação que realmente implementa o recurso solicitado.

• Quando usa a ClaimsPrincipalPermission classe ou a ClaimsPrincipalPermissionAttribute classe para realizar verificações de acesso baseadas em reclamações imperativas ou declarativas no seu código, o gestor de autorização de reclamações configurado para a sua aplicação é chamado pelo sistema para realizar a verificação. Verificações de acesso baseadas em sinistros podem ser realizadas tanto em aplicações web como em aplicações de ambiente de trabalho.

A implementação padrão fornecida pela ClaimsAuthorizationManager classe autoriza o acesso para cada reivindicação apresentada; no entanto, pode derivar desta classe e sobrepor o CheckAccess método para fornecer a sua própria lógica de autorização.

A utilização de um gestor de autorização de sinistros é opcional. Pode configurar a sua aplicação para usar um gestor de autorização de reclamações, seja programaticamente usando a IdentityConfiguration classe ou declarativamente, especificando o <elemento claimsAuthorizationManager> , que é um elemento filho do <elemento identityConfiguration> no ficheiro de configuração da sua aplicação. Se a sua aplicação for um site web ou uma aplicação web alojada em Serviços de Informação Internet (IIS), deve também adicionar o ClaimsAuthorizationModule na coleção de Módulos HTTP ASP.NET.

A ClaimsAuthorizationManager classe base não aceita qualquer configuração adicional; no entanto, pode sobrescrever as LoadCustomConfiguration classes derivadas in para fornecer inicialização do seu gestor de autorização de reivindicações a partir dos elementos filhos do <claimsAuthorizationElement>. O cenário típico é usar estes elementos filhos para especificar políticas de autorização que determinam que tipos e valores de reivindicação são necessários para aceder a que recurso. Isto não é um requisito rígido, embora sejas livre de definir o uso e a sintaxe que fizer sentido para a tua implementação.