ClaimsPrincipalPermission Classe

Definição

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 .

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

Métodos

Aplica-se a

Confira também

• ClaimsPrincipalPermissionAttribute
• FederationConfiguration
• ClaimsAuthorizationManager
• <federationConfiguration>