PrincipalPermissionMode Énumération

Définition

Espace de noms:

System.ServiceModel.Description

Assembly:

System.ServiceModel.dll

Définit le mode pour les contrôles d'autorisation lors de l'utilisation de l'PrincipalPermissionAttribute pour contrôler l'accès à une méthode.

C#

public enum PrincipalPermissionMode

Héritage

Object

ValueType

Enum

PrincipalPermissionMode

Champs

Nom	Valeur	Description
Always	4	Permet toujours à l'utilisateur de spécifier une classe IPrincipal pour CurrentPrincipal.
Custom	3	Permet à l'utilisateur de spécifier une classe IPrincipal personnalisée pour CurrentPrincipal.
None	0	CurrentPrincipal n'est pas définie.
UseAspNetRoles	2	CurrentPrincipal est défini en fonction du fournisseur de rôle ASP.NET (RoleProvider).
UseWindowsGroups	1	CurrentPrincipal est définie en fonction de Windows (WindowsPrincipal). Si l'identité de l'utilisateur n'est pas associée à un compte Windows, un utilisateur Windows anonyme est utilisé.

Exemples

L’exemple suivant montre comment spécifier UseAspNetRoles.

C#

namespace TestPrincipalPermission
{
    class PrincipalPermissionModeWindows
    {

        [ServiceContract]
        interface ISecureService
        {
            [OperationContract]
            string Method1();
        }

        class SecureService : ISecureService
        {
            [PrincipalPermission(SecurityAction.Demand, Role = "everyone")]
            public string Method1()
            {
                return String.Format("Hello, \"{0}\"", Thread.CurrentPrincipal.Identity.Name);
            }
        }

        public void Run()
        {
            Uri serviceUri = new Uri(@"http://localhost:8006/Service");
            ServiceHost service = new ServiceHost(typeof(SecureService));
            service.AddServiceEndpoint(typeof(ISecureService), GetBinding(), serviceUri);
            service.Authorization.PrincipalPermissionMode = PrincipalPermissionMode.UseAspNetRoles;
            service.Open();

            EndpointAddress sr = new EndpointAddress(
                serviceUri, EndpointIdentity.CreateUpnIdentity(WindowsIdentity.GetCurrent().Name));
            ChannelFactory<ISecureService> cf = new ChannelFactory<ISecureService>(GetBinding(), sr);
            ISecureService client = cf.CreateChannel();
            Console.WriteLine("Client received response from Method1: {0}", client.Method1());
            ((IChannel)client).Close();
            Console.ReadLine();
            service.Close();
        }

        public static Binding GetBinding()
        {
            WSHttpBinding binding = new WSHttpBinding(SecurityMode.Message);
            binding.Security.Message.ClientCredentialType = MessageCredentialType.Windows;
            return binding;
        }
    }
}

L’exemple suivant montre comment spécifier Custom.

C#

namespace CustomMode
{
    public class Test
    {
        public static void Main()
        {
            try
            {
                ShowPrincipalPermissionModeCustom ppwm = new ShowPrincipalPermissionModeCustom();
                ppwm.Run();
            }
            catch (Exception exc)
            {
                Console.WriteLine("Error: {0}", exc.Message);
                Console.ReadLine();
            }
        }
    }

    class ShowPrincipalPermissionModeCustom
    {
        [ServiceContract]
        interface ISecureService
        {
            [OperationContract]
            string Method1(string request);
        }

        [ServiceBehavior]
        class SecureService : ISecureService
        {
            [PrincipalPermission(SecurityAction.Demand, Role = "everyone")]
            public string Method1(string request)
            {
                return String.Format("Hello, \"{0}\"", Thread.CurrentPrincipal.Identity.Name);
            }
        }

        public void Run()
        {
            Uri serviceUri = new Uri(@"http://localhost:8006/Service");
            ServiceHost service = new ServiceHost(typeof(SecureService));
            service.AddServiceEndpoint(typeof(ISecureService), GetBinding(), serviceUri);
            List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>();
            policies.Add(new CustomAuthorizationPolicy());
            service.Authorization.ExternalAuthorizationPolicies = policies.AsReadOnly();
            service.Authorization.PrincipalPermissionMode = PrincipalPermissionMode.Custom;
            service.Open();

            EndpointAddress sr = new EndpointAddress(
                serviceUri, EndpointIdentity.CreateUpnIdentity(WindowsIdentity.GetCurrent().Name));
            ChannelFactory<ISecureService> cf = new ChannelFactory<ISecureService>(GetBinding(), sr);
            ISecureService client = cf.CreateChannel();
            Console.WriteLine("Client received response from Method1: {0}", client.Method1("hello"));
            ((IChannel)client).Close();
            Console.ReadLine();
            service.Close();
        }

        public static Binding GetBinding()
        {
            WSHttpBinding binding = new WSHttpBinding(SecurityMode.Message);
            binding.Security.Message.ClientCredentialType = MessageCredentialType.Windows;
            return binding;
        }

        class CustomAuthorizationPolicy : IAuthorizationPolicy
        {
            string id = Guid.NewGuid().ToString();

            public string Id
            {
                get { return this.id; }
            }

            public ClaimSet Issuer
            {
                get { return ClaimSet.System; }
            }

            public bool Evaluate(EvaluationContext context, ref object state)
            {
                object obj;
                if (!context.Properties.TryGetValue("Identities", out obj))
                    return false;

                IList<IIdentity> identities = obj as IList<IIdentity>;
                if (obj == null || identities.Count <= 0)
                    return false;

                context.Properties["Principal"] = new CustomPrincipal(identities[0]);
                return true;
            }
        }

        class CustomPrincipal : IPrincipal
        {
            IIdentity identity;
            public CustomPrincipal(IIdentity identity)
            {
                this.identity = identity;
            }

            public IIdentity Identity
            {
                get { return this.identity; }
            }

            public bool IsInRole(string role)
            {
                return true;
            }
        }
    }
}

Remarques

Lors de l'application de l'PrincipalPermissionAttribute à une méthode, ce mode spécifie le jeu de rôles à utiliser lors de l'autorisation d'accès. Par défaut, l'attribut utilise les groupes Windows (tels que Administrator ou Users) pour spécifier le rôle auquel l'utilisateur doit appartenir.

Pour définir le mode par programme, créez une instance de la classe ServiceHost, puis recherchez le ServiceAuthorizationBehavior dans sa collection de comportements et affectez au PrincipalPermissionMode l'énumération appropriée. L’exemple suivant définit la propriété sur UseAspNetRoles.

C#

ServiceHost myServiceHost = new ServiceHost(typeof(Calculator), baseUri);
ServiceAuthorizationBehavior myServiceBehavior =
    myServiceHost.Description.Behaviors.Find<ServiceAuthorizationBehavior>();
myServiceBehavior.PrincipalPermissionMode =
    PrincipalPermissionMode.UseAspNetRoles;

Vous pouvez également définir le comportement dans la configuration en ajoutant un <serviceAuthorization> au <serviceBehaviors> d’un fichier de configuration, comme indiqué dans le code suivant.

C#

// Only a client authenticated with a valid certificate that has the
// specified subject name and thumbprint can call this method.
[PrincipalPermission(SecurityAction.Demand,
     Name = "CN=ReplaceWithSubjectName; 123456712345677E8E230FDE624F841B1CE9D41E")]
public double Multiply(double a, double b)
{
    return a * b;
}

L'énumération affecte la façon dont l'attribut PrincipalPermissionAttribute autorise un utilisateur lors de son application à une méthode. L'exemple suivant applique l'attribut à une méthode et exige que l'utilisateur appartienne au groupe Utilisateurs sur l'ordinateur. Ce code ne fonctionne que lorsque le PrincipalPermissionMode a la valeur UseWindowsGroup (paramètre par défaut).

C#

// Only members of the CalculatorClients group can call this method.
[PrincipalPermission(SecurityAction.Demand, Role = "Users")]
public double Add(double a, double b)
{
    return a + b;
}

UseAspNetRoles

La valeur UseAspNetRoles est utilisée pour tous les types d’informations d’identification. Ce mode permet à Windows Communication Foundation (WCF) d’utiliser le fournisseur de rôles ASP.NET pour prendre des décisions d’autorisation.

Lorsque l'information d'identification d'un service est un certificat X.509, vous pouvez affecter à la propriété Name de PrincipalPermissionAttribute une chaîne qui se compose des valeurs concaténées des champs Sujet et Empreinte digitale, comme illustré dans l'exemple suivant.

C#

ServiceHost myServiceHost = new ServiceHost(typeof(Calculator), baseUri);
ServiceAuthorizationBehavior myServiceBehavior =
    myServiceHost.Description.Behaviors.Find<ServiceAuthorizationBehavior>();
myServiceBehavior.PrincipalPermissionMode =
    PrincipalPermissionMode.UseAspNetRoles;
MyServiceAuthorizationManager sm = new MyServiceAuthorizationManager();
myServiceBehavior.ServiceAuthorizationManager = sm;

La chaîne concaténée se compose des valeurs de sujet et d'empreinte digitale, séparées par un point-virgule et un espace.

Il est également possible que le champ Sujet d'un certificat ait la valeur d'une chaîne null. Dans ce cas, vous pouvez affecter à la propriété Name un point-virgule suivi d'un espace puis de l'empreinte digitale, comme illustré dans l'exemple suivant.

C#

// Only a client authenticated with a valid certificate that has the
// specified thumbprint can call this method.
[PrincipalPermission(SecurityAction.Demand,
     Name = "; 123456712345677E8E230FDE624F841B1CE9D41E")]
public double Divide(double a, double b)
{
    return a * b;
}

Si un fournisseur de rôle ASP.NET est présent, vous pouvez également affecter à la propriété Role un rôle dans la base de données. Par défaut, la base de données est représentée par le SqlRoleProvider. Vous pouvez également définir un fournisseur de rôle personnalisé avec la propriété RoleProvider de la classe ServiceAuthorizationBehavior. Le code suivant affecte au rôle la valeur Administrators. Notez que le fournisseur de rôle doit mapper le compte d'utilisateur sur ce rôle.

C#

[PrincipalPermission(SecurityAction.Demand, Role = "Administrators")]
public string ReadFile(string fileName)
{
    // Code not shown.
    return "Not implemented";
}

Pour plus d’informations sur l’utilisation de WCF et du fournisseur de rôles, consultez How to: Use the ASP.NET Role Provider with a Service.

Custom

Lorsque la propriété est définie sur Personnalisé, vous devez également fournir une classe personnalisée qui implémente la IAuthorizationPolicy classe . Cette classe est chargée de fournir la représentation IPrincipal de l'appelant dans la collection Properties. Elle doit stocker l’instance IPrincipal dans la collection de propriétés à l’aide de la clé de chaîne « Entités de sécurité », comme illustré dans l’exemple suivant.

evaluationContext.Properties["Principal"]=new CustomPrincipal(identity);  

Arrière-plan

La sécurité basée sur les rôles dans .NET Framework permet aux applications de spécifier des autorisations par le biais du code. En spécifiant la demande PrincipalPermission, la propriété CurrentPrincipal doit satisfaire la spécification PrincipalPermission. Par exemple, que l'utilisateur doit se trouver dans un rôle ou un groupe spécifique. Sinon, le thread n'est pas autorisé à exécuter le code, entraînant ainsi une exception. WCF fournit un ensemble de PrincipalPermissionMode sélections pour spécifier le CurrentPrincipal en SecurityContext fonction de en conséquence.

S’applique à