ClaimsPrincipalPermission Classe

Referência

Definição

Namespace:: System.IdentityModel.Services

Assembly:: System.IdentityModel.Services.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa uma permissão que usa uma implementação ClaimsAuthorizationManager para determinar se o acesso a um recurso deve ser concedido à entidade de segurança ativa. Essa classe não pode ser herdada.

public ref class ClaimsPrincipalPermission sealed : System::Security::IPermission, System::Security::Permissions::IUnrestrictedPermission

[System.Serializable]
public sealed class ClaimsPrincipalPermission : System.Security.IPermission, System.Security.Permissions.IUnrestrictedPermission

[<System.Serializable>]
type ClaimsPrincipalPermission = class
    interface IPermission
    interface ISecurityEncodable
    interface IUnrestrictedPermission

Public NotInheritable Class ClaimsPrincipalPermission
Implements IPermission, IUnrestrictedPermission

Herança: Object
ClaimsPrincipalPermission

Atributos: SerializableAttribute

Implementações: IPermission ISecurityEncodable IUnrestrictedPermission

Exemplos

O exemplo a seguir mostra como proteger um recurso usando o Demand método, o CheckAccess método ou uma ClaimsPrincipalPermissionAttribute declaração. Em cada caso, o configurado ClaimsAuthorizationManager é invocado para avaliar a entidade de segurança atual em relação ao recurso e à ação especificados. Se a entidade de segurança atual não estiver autorizada para a ação especificada no recurso especificado, um SecurityException será gerado; caso contrário, a execução continuará.

using System;
using System.IdentityModel.Services;
using System.Security.Claims;
using System.Security.Permissions;
using System.Threading;

namespace ClaimsBasedAuthorization
{
    /// <summary>
    /// Program illustrates using Claims-based authorization
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //
            // Method 1. Simple access check using static method. 
            // Expect this to be most common method.
            //
            ClaimsPrincipalPermission.CheckAccess("resource", "action");

            //
            // Method 2. Programmatic check using the permission class
            // Follows model found at http://msdn.microsoft.com/library/system.security.permissions.principalpermission.aspx
            //
            ClaimsPrincipalPermission cpp = new ClaimsPrincipalPermission("resource", "action");
            cpp.Demand();

            //
            // Method 3. Access check interacting directly with the authorization manager.
            //            
            ClaimsAuthorizationManager am = new ClaimsAuthorizationManager();
            am.CheckAccess(new AuthorizationContext((ClaimsPrincipal)Thread.CurrentPrincipal, "resource", "action"));

            //
            // Method 4. Call a method that is protected using the permission attribute class
            //
            ProtectedMethod();

            Console.WriteLine("Press [Enter] to continue.");
            Console.ReadLine();
        }

        //
        // Declarative access check using the permission class. The caller must satisfy both demands.
        //
        [ClaimsPrincipalPermission(SecurityAction.Demand, Resource = "resource", Operation = "action")]
        [ClaimsPrincipalPermission(SecurityAction.Demand, Resource = "resource1", Operation = "action1")]
        static void ProtectedMethod()
        {
        }
    }
}

O XML a seguir mostra a configuração mínima necessária para usar um gerenciador de autorização de declarações personalizado com a ClaimsPrincipalPermission classe . Você deve, no mínimo, declarar as system.identityModel seções e system.identityModel.services no elemento e especificar o <configSection> gerenciador de autorização em um <elemento claimsAuthorizationManager> na configuração de identidade padrão. Isso garantirá que o gerenciador de autorização seja referenciado a partir da configuração de federação padrão. Como alternativa, você pode especificar o nome da configuração de identidade sob a qual o gerenciador de autorização é especificado no identityConfigurationName atributo do <elemento federationConfiguration> .

<?xml version="1.0" encoding="utf-8" ?>  
<configuration>  
  <configSections>  
    <!-- WIF configuration sections -->  
    <section name="system.identityModel" type="System.IdentityModel.Configuration.SystemIdentityModelSection, System.IdentityModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>  
    <section name="system.identityModel.services" type="System.IdentityModel.Services.Configuration.SystemIdentityModelServicesSection, System.IdentityModel.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>  
  </configSections>  

  <startup>  
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />  
  </startup>  

  <system.identityModel>  
    <identityConfiguration>  
      <claimsAuthorizationManager type ="MyClaimsAuthorizationManager.MyClaimsAuthorizationManager, MyClaimsAuthorizationManager"/>  
    </identityConfiguration>  
  </system.identityModel>  

</configuration>

Comentários

A ClaimsPrincipalPermission classe fornece a capacidade de executar verificações de acesso imperativas usando o ClaimsAuthorizationManager configurado para um aplicativo. Ao invocar o Demand método ou o método estático CheckAccess , você pode fornecer proteção aos recursos de dentro do caminho de execução do código de acordo com a política de autorização definida para o gerenciador de autenticação de declarações. As verificações de acesso declarativo podem ser executadas usando a ClaimsPrincipalPermissionAttribute classe .

Importante

A ClaimsPrincipalPermission classe usa o gerenciador de autorização de declarações configurado pelo IdentityConfiguration que é definido na FederatedAuthentication.FederationConfiguration propriedade . Isso é verdadeiro em todos os casos, mesmo em cenários em que WS-Federation não é usado; por exemplo, aplicativos Web ativos (WCF) e aplicativos de console. Você pode especificar o gerenciador de autorização de declarações na configuração ou programaticamente. Para especificar o gerenciador de autorização de declarações em um arquivo de configuração, defina o <elemento claimsAuthorizationManager> em um <elemento identityConfiguration> e verifique se essa configuração de identidade é referenciada pelo <elemento federationConfiguration> carregado pelo runtime (por exemplo, definindo o identityConfigurationName atributo). Para definir o gerenciador de autorização de declarações programaticamente, forneça um manipulador para o FederatedAuthentication.FederationConfigurationCreated evento.

Em um nível, a funcionalidade fornecida por ClaimsPrincipalPermission é semelhante às RBAC (verificações de acesso baseadas em função) fornecidas por meio da PrincipalPermission classe ; no entanto, a ClaimsAuthorizationManager classe executa verificações com base nas declarações apresentadas pela entidade de segurança ativa. Isso permite muito mais granularidade do que está disponível por meio do RBAC puro, em que muitas permissões normalmente são coletadas sob uma única função. Talvez, mais importante, a autorização baseada em declarações permita uma melhor separação da lógica de negócios e da política de autorização porque a permissão pode ser exigida para uma ação específica em um recurso no código e a política de back-end pode ser usada para configurar quais declarações a entidade de apresentação deve possuir para atender à demanda. Assim como o RBAC, ClaimsPrincipalPermission executa um marcar de acesso baseado no usuário, ou seja, ao contrário da segurança de acesso de código implementada por classes que derivam da CodeAccessPermission classe e usam um passo a passo de pilha para garantir que todos os chamadores do código tenham recebido uma permissão, ClaimsPrincipalPermission execute seus marcar apenas na entidade de segurança atual.

O método estático CheckAccess verifica o acesso a uma ação especificada em um recurso especificado. O recurso e a ação são cadeias de caracteres e normalmente são URIs. Você também pode inicializar uma instância de ClaimsPrincipalPermission com uma ação e um recurso e chamar o Demand método . Embora o construtor use apenas um único recurso e uma ação, ClaimsPrincipalPermission os objetos podem ser combinados por meio dos Union métodos e Intersect . Uma permissão criada usando esses métodos pode conter vários pares de ação de recurso.

Ambos os métodos determinam o acesso invocando o ClaimsAuthorizationManager.CheckAccess método do gerenciador de autorização de declarações configurado com um AuthorizationContext composto da entidade de segurança ativa (Thread.CurrentPrincipal), do recurso e da ação. Eles lançam um SecurityException se a entidade de segurança atual não estiver autorizada a executar a ação no recurso; caso contrário, a execução continuará.

No caso de um que contém vários pares de ação de recurso, o ClaimsAuthorizationManager.CheckAccess método é invocado para cada um ClaimsPrincipalPermission dos pares de ação de recurso contidos na permissão. Para que a chamada seja Demand bem-sucedida, a entidade de segurança ativa deve ser autorizada para todos os pares de ação de recurso contidos na permissão.

Construtores

ClaimsPrincipalPermission(String, String)

Cria uma nova instância da classe ClaimsPrincipalPermission.

Métodos

CheckAccess(String, String)	Verifica se a entidade de segurança atual está autorizada a executar a ação especificada no recurso especificado.
Copy()	Retorna uma cópia da instância ClaimsPrincipalPermission atual.
Demand()	Verifica se a entidade atual tem autorização para os pares de ação de recurso associados à instância atual.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
FromXml(SecurityElement)	Reconstrói a permissão atual e seu estado com base na codificação de XML especificada.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
Intersect(IPermission)	Retorna uma permissão que é a interseção da permissão atual e da permissão especificada.
IsSubsetOf(IPermission)	Retorna um valor que indica se a permissão atual é um subconjunto da permissão especificada.
IsUnrestricted()	Retorna um valor que indica se a permissão é irrestrita.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
ToXml()	Retorna a forma codificada em XML da permissão atual e do respectivo estado.
Union(IPermission)	Retorna uma nova permissão que é a união da permissão atual e da permissão especificada. O objeto ClaimsPrincipalPermission que tem todos os pares de ação de recurso que estão presentes na instância atual e na instância de destino.

Aplica-se a

Partilhar via