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 seguinte mostra como proteger um recurso usando o Demand método, o CheckAccess método ou uma ClaimsPrincipalPermissionAttribute declaração. Em cada caso, a configuração ClaimsAuthorizationManager é invocada para avaliar o principal atual em relação ao recurso e ação especificados. Se o principal atual não estiver autorizado para a ação especificada sobre o recurso especificado, um SecurityException é lançado; caso contrário, a execução prossegue.

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 seguinte mostra a configuração mínima necessária para usar um gestor personalizado de autorização de reclamações com a ClaimsPrincipalPermission classe. Deve, no mínimo, declarar tanto as secções como system.identityModelsystem.identityModel.services as do <configSection> elemento e depois especificar o seu gestor de autorizações num <elemento claimsAuthorizationManager> na configuração de identidade predefinida. Isto garantirá que o seu gestor de autorizações é referenciado a partir da configuração padrão da federação. Em alternativa, pode especificar o nome da configuração de identidade sob a qual o seu gestor 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>

Observações

A ClaimsPrincipalPermission classe oferece a capacidade de realizar verificações de acesso imperativas utilizando o ClaimsAuthorizationManager que está configurado para uma aplicação. Ao invocar o Demand método ou o método estático CheckAccess , pode fornecer proteção aos recursos a partir do caminho de execução do seu código, de acordo com a política de autorização definida para o gestor de autenticação de sinistros. Verificações declarativas de acesso podem ser realizadas utilizando a ClaimsPrincipalPermissionAttribute classe.

Por um lado, a funcionalidade fornecida ClaimsPrincipalPermission por é semelhante às verificações de acesso baseadas em funções (RBAC) fornecidas pela PrincipalPermission classe; no entanto, a ClaimsAuthorizationManager classe realiza verificações com base nas reivindicações apresentadas pelo principal ativo. Isto permite uma granularidade muito maior do que a disponível através do RBAC puro, onde muitas permissões são normalmente recolhidas sob um único papel. Talvez, mais importante, a autorização baseada em reivindicações permita uma melhor separação entre lógica de negócio e política de autorização, porque pode ser exigida permissão para uma ação específica sobre um recurso no código e a política de back-end pode ser usada para configurar quais reivindicações a entidade apresentadora deve possuir para satisfazer a procura. Tal como o RBAC, ClaimsPrincipalPermission realiza uma verificação de acesso baseada no utilizador, isto é, ao contrário da segurança de acesso ao código implementada por classes que derivam da CodeAccessPermission classe e usam um passeio de pilha para garantir que todos os chamadores do código receberam uma permissão, realiza ClaimsPrincipalPermission a verificação apenas no principal atual.

O método estático CheckAccess verifica o acesso para uma ação específica num recurso especificado. O recurso e a ação são ambos strings e normalmente são URIs. 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 recurso e uma ação, ClaimsPrincipalPermission os objetos podem ser combinados através dos Union métodos e.Intersect Uma permissão criada através destes métodos pode conter múltiplos pares recurso-ação.

Ambos os métodos determinam o acesso invocando o ClaimsAuthorizationManager.CheckAccess método do gestor de autorização de sinistros configurado com um AuthorizationContext composto pelo principal ativo (Thread.CurrentPrincipal), o recurso e a ação. Eles lançam a SecurityException se o principal atual não estiver autorizado a realizar a ação sobre o recurso; caso contrário, a execução prossegue.

No caso de um ClaimsPrincipalPermission que contém múltiplos pares recurso-ação, o ClaimsAuthorizationManager.CheckAccess método é invocado para cada um dos pares recurso-ação contidos na permissão. Para que a chamada Demand tenha sucesso, o principal ativo deve estar autorizado para todos os pares recurso-ação contidos na permissão.

Ver também

• ClaimsPrincipalPermissionAttribute
• FederationConfiguration
• ClaimsAuthorizationManager
• <federaçãoConfiguração>