ClaimsPrincipalPermission Classe

Définition

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
ClaimsPrincipalPermission
Attributs
Implémente

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, une SecurityException exception est levée ; sinon, l’exécution continue.

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

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’autorisations de revendications personnalisées avec la ClaimsPrincipalPermission classe. Vous devez au minimum déclarer les system.identityModel system.identityModel.services sections et dans l' <configSection> élément, puis spécifier votre gestionnaire d’autorisations dans un élément < claimsAuthorizationManager > sous la configuration d’identité par défaut. Cela permet de s’assurer 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' identityConfigurationName attribut 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 offre la possibilité d’effectuer des vérifications d’accès impératives à l’aide du ClaimsAuthorizationManager configuré pour une application. En appelant la Demand méthode ou la 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 contrôles d’accès déclaratifs peuvent être effectués à l’aide de la ClaimsPrincipalPermissionAttribute classe.

Important

La ClaimsPrincipalPermission classe utilise le gestionnaire d’autorisations des revendications configuré par le IdentityConfiguration 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’autorisations des revendications dans la configuration ou par programme. Pour spécifier le gestionnaire d’autorisations 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' identityConfigurationName attribut). Pour définir le gestionnaire d’autorisations des revendications par programme, fournissez un gestionnaire pour l' FederatedAuthentication.FederationConfigurationCreated événement.

À un niveau, les fonctionnalités fournies par ClaimsPrincipalPermission sont similaires aux contrôles d’accès en fonction du rôle (RBAC) fournis 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 une plus grande granularité que celle disponible par le biais du RBAC pur, où de nombreuses autorisations sont généralement collectées sous un seul rôle. 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é de présentation doit posséder afin de satisfaire la demande. Comme RBAC, ClaimsPrincipalPermission effectue une vérification de l’accès en fonction de l’utilisateur, c’est-à-dire, à la différence de la sécurité d’accès du code implémentée par les classes qui dérivent de la CodeAccessPermission classe et utilisent un parcours de la pile pour s’assurer que tous les appelants du code ont reçu une autorisation, ClaimsPrincipalPermission effectue sa vérification uniquement sur le principal actuel.

La CheckAccess méthode statique vérifie l’accès pour une action spécifiée sur une ressource spécifiée. La ressource et l’action sont à la fois des chaînes et sont généralement des URI. Vous pouvez également initialiser une instance de ClaimsPrincipalPermission avec une action et une ressource, puis appeler la Demand méthode. Même si le constructeur ne prend qu’une seule ressource et action, les ClaimsPrincipalPermission objets peuvent être combinés via les Union Intersect méthodes et. 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’autorisations des revendications configuré avec un AuthorizationContext composé du principal actif ( Thread.CurrentPrincipal ), de la ressource et de l’action. Elles lèvent une SecurityException si le principal actuel n’est pas autorisé à effectuer l’action sur la ressource ; sinon, l’exécution continue.

Dans le cas d’un ClaimsPrincipalPermission qui contient plusieurs paires ressource-action, la ClaimsAuthorizationManager.CheckAccess méthode est appelée pour chacune des paires ressource-action contenues dans l’autorisation. Pour que l’appel à Demand aboutisse, 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 à

Voir aussi