ClaimsAuthorizationManager.CheckAccess(AuthorizationContext) Método

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

Devoluções

true se o sujeito estiver autorizado a realizar a ação especificada sobre o recurso especificado; caso contrário, false.

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 sobreposição do CheckAccess método. Este método concede ou nega acesso com base numa política lida e compilada a partir do ficheiro 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 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;
        }
    }
}

A apólice utilizada pelo gestor de autorização de reclamações é especificada por elementos personalizados <policy> no <elemento claimsAuthorizationManager> . Esta política é lida e compilada pelo LoadCustomConfiguration método. 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.

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

Observações

A implementação base devolve truesempre , que autoriza o acesso. Pode sobrescrever este método numa classe derivada para autorizar o acesso com base nos requisitos da sua aplicação RP. Se este método devolver false, Windows Fundação de Identidade (WIF) devolve um erro não autorizado ao chamador; caso contrário, a execução é passada para a aplicação RP.