ClaimsPrincipalPermission Classe

Référence

Définition

Espace de noms:: System.IdentityModel.Services

Assembly:: System.IdentityModel.Services.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente une autorisation qui utilise une implémentation de ClaimsAuthorizationManager pour déterminer si l'accès à une ressource doit être accordé à l'entité de sécurité active. Cette classe ne peut pas être héritée.

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

Héritage: Object
ClaimsPrincipalPermission

Attributs: SerializableAttribute

Implémente: IPermission ISecurityEncodable IUnrestrictedPermission

Exemples

L’exemple suivant montre comment protéger une ressource à l’aide de la Demand méthode, de la CheckAccess méthode ou d’une ClaimsPrincipalPermissionAttribute déclaration. Dans chaque cas, le configuré ClaimsAuthorizationManager est appelé pour évaluer le principal actuel par rapport à la ressource et à l’action spécifiées. Si le principal actuel n’est pas autorisé pour l’action spécifiée sur la ressource spécifiée, un SecurityException est levée ; sinon, l’exécution se poursuit.

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()
        {
        }
    }
}

Le code XML suivant montre la configuration minimale requise pour utiliser un gestionnaire d’autorisation de revendications personnalisées avec la ClaimsPrincipalPermission classe . Vous devez au minimum déclarer les system.identityModel sections et de <configSection> l’élémentsystem.identityModel.services, puis spécifier votre gestionnaire d’autorisations dans un <élément claimsAuthorizationManager> sous la configuration d’identité par défaut. Cela garantit que votre gestionnaire d’autorisations est référencé à partir de la configuration de fédération par défaut. Vous pouvez également spécifier le nom de la configuration d’identité sous laquelle votre gestionnaire d’autorisations est spécifié dans l’attribut identityConfigurationName de l’élément <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>

Remarques

La ClaimsPrincipalPermission classe permet d’effectuer des vérifications d’accès impératives à l’aide de ClaimsAuthorizationManager qui est configuré pour une application. En appelant la méthode ou la Demand méthode statique CheckAccess , vous pouvez fournir une protection aux ressources à partir du chemin d’exécution de votre code en fonction de la stratégie d’autorisation définie pour votre gestionnaire d’authentification des revendications. Les vérifications d’accès déclaratives peuvent être effectuées à l’aide de la ClaimsPrincipalPermissionAttribute classe .

Important

La ClaimsPrincipalPermission classe utilise le gestionnaire d’autorisation des revendications configuré par qui IdentityConfiguration est défini sous la FederatedAuthentication.FederationConfiguration propriété . Cela est vrai dans tous les cas, même dans les scénarios où WS-Federation n’est pas utilisé ; par exemple, les applications web actives (WCF) et les applications console. Vous pouvez spécifier le gestionnaire d’autorisation des revendications dans la configuration ou par programme. Pour spécifier le gestionnaire d’autorisation des revendications dans un fichier de configuration, définissez l’élément <claimsAuthorizationManager> sous un <élément identityConfiguration> et assurez-vous que cette configuration d’identité est référencée par l’élément <federationConfiguration> chargé par le runtime (par exemple, en définissant l’attribut identityConfigurationName ). Pour définir le gestionnaire d’autorisation des revendications par programmation, fournissez un gestionnaire pour l’événement FederatedAuthentication.FederationConfigurationCreated .

À un niveau, la fonctionnalité fournie par ClaimsPrincipalPermission est similaire aux vérifications d’accès en fonction du rôle (RBAC) fournies par le biais de la PrincipalPermission classe ; toutefois, la ClaimsAuthorizationManager classe effectue des vérifications basées sur les revendications présentées par le principal actif. Cela permet beaucoup plus de granularité que n’en dispose le RBAC pur, où de nombreuses autorisations sont généralement collectées sous un seul rôle. Peut-être, plus important encore, l’autorisation basée sur les revendications permet une meilleure séparation de la logique métier et de la stratégie d’autorisation, car l’autorisation peut être demandée pour une action spécifique sur une ressource dans le code et la stratégie principale peut être utilisée pour configurer les revendications que l’entité présente doit posséder afin de répondre à la demande. Comme RBAC, ClaimsPrincipalPermission effectue un case activée d’accès basé sur l’utilisateur, c’est-à-dire, contrairement à la sécurité d’accès au code implémentée par les classes qui dérivent de la CodeAccessPermission classe et utilisent une procédure de pile pour s’assurer que tous les appelants du code ont obtenu une autorisation, ClaimsPrincipalPermission effectue son case activée uniquement sur le principal actuel.

La méthode statique CheckAccess vérifie l’accès pour une action spécifiée sur une ressource spécifiée. La ressource et l’action sont des chaînes et sont généralement des URI. Vous pouvez également initialiser un instance de ClaimsPrincipalPermission avec une action et une ressource et appeler la Demand méthode. Bien que le constructeur ne prenne qu’une seule ressource et une seule action, ClaimsPrincipalPermission les objets peuvent être combinés via les Union méthodes et Intersect . Une autorisation créée à l’aide de ces méthodes peut contenir plusieurs paires ressource-action.

Les deux méthodes déterminent l’accès en appelant la ClaimsAuthorizationManager.CheckAccess méthode du gestionnaire d’autorisation des revendications configuré avec un AuthorizationContext composé du principal actif (Thread.CurrentPrincipal), de la ressource et de l’action. Ils lèvent un SecurityException si le principal actuel n’est pas autorisé à effectuer l’action sur la ressource ; sinon, l’exécution se poursuit.

Dans le cas d’un ClaimsPrincipalPermission qui contient plusieurs paires resource-action, la ClaimsAuthorizationManager.CheckAccess méthode est appelée pour chacune des paires resource-action contenues dans l’autorisation. Pour que l’appel à Demand réussisse, le principal actif doit être autorisé pour toutes les paires ressource-action contenues dans l’autorisation.

Constructeurs

ClaimsPrincipalPermission(String, String)

Crée une instance de la classe ClaimsPrincipalPermission.

Méthodes

CheckAccess(String, String)	Vérifie si le principal de sécurité en cours est autorisé à exécuter l'action spécifiée sur la ressource spécifiée.
Copy()	Retourne une copie de l'instance de ClaimsPrincipalPermission en cours.
Demand()	Vérifie si le principal en cours est autorisé pour les paires ressource-action associées à l'instance actuelle.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
FromXml(SecurityElement)	Reconstruit l'autorisation actuelle et son état à partir de l'encodage XML spécifié.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Intersect(IPermission)	Retourne une autorisation correspondant à l'intersection de l'autorisation actuelle et de l'autorisation spécifiée.
IsSubsetOf(IPermission)	Retourne une valeur qui indique si l'autorisation en cours est un sous-ensemble de l'autorisation spécifiée.
IsUnrestricted()	Retourne une valeur qui indique si l’autorisation est illimitée.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
ToXml()	Retourne l’autorisation actuelle et son état sous forme de codage XML.
Union(IPermission)	Retourne une nouvelle autorisation correspondant à l'union de l'autorisation actuelle et de l'autorisation spécifiée. Objet ClaimsPrincipalPermission qui présente toutes les paires de ressource-action qui sont présentes dans l'instance actuelle et l'instance cible.

S’applique à