Partilhar via


ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Método

Definição

Quando implementado em uma classe derivada, verifica a entidade na autorização no contexto especificado para executar a ação especificada no recurso especificado.

public:
 virtual bool CheckAccess(System::Security::Claims::AuthorizationContext ^ context);
public virtual bool CheckAccess (System.Security.Claims.AuthorizationContext context);
abstract member CheckAccess : System.Security.Claims.AuthorizationContext -> bool
override this.CheckAccess : System.Security.Claims.AuthorizationContext -> bool
Public Overridable Function CheckAccess (context As AuthorizationContext) As Boolean

Parâmetros

context
AuthorizationContext

O contexto de autorização que contém a entidade, os recursos e a ação para os quais a autorização deve ser verificada.

Retornos

Boolean

true se a entidade estiver autorizada a executar a ação especificada no recurso especificado; caso contrário, false.

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 ClaimsAuthorizationManager do 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 para fins de brevidade. Para obter informações sobre este exemplo e outros exemplos disponíveis para WIF e sobre onde baixá-los, consulte o Índice de Exemplo de Código WIF.

O código a seguir mostra a substituição do CheckAccess método. Esse método concede ou nega acesso com base em uma política lida e compilada do arquivo de configuração.

static Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>> _policies = new Dictionary<ResourceAction, Func<ClaimsPrincipal, bool>>();
PolicyReader _policyReader = new PolicyReader();
    /// <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;
        }
    }
}

A política usada pelo gerenciador de autorização de declarações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Essa política é lida e compilada pelo LoadCustomConfiguration método. 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.

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

Comentários

A implementação base sempre retorna true, o que autoriza o acesso. Você pode substituir esse método em uma classe derivada para autorizar o acesso com base nos requisitos do aplicativo RP. Se esse método retornarfalse, Windows Identity Foundation (WIF) retornará um erro não autorizado ao chamador; caso contrário, a execução será passada para o aplicativo RP.

Aplica-se a