RegistryAccessRule Classe

Définition

Espace de noms:

System.Security.AccessControl

Assembly:

Microsoft.Win32.Registry.dll

Représente un jeu de droits d'accès accordés ou refusés à un utilisateur ou à un groupe. Cette classe ne peut pas être héritée.

public ref class RegistryAccessRule sealed : System::Security::AccessControl::AccessRule

public sealed class RegistryAccessRule : System.Security.AccessControl.AccessRule

type RegistryAccessRule = class
    inherit AccessRule

Public NotInheritable Class RegistryAccessRule
Inherits AccessRule

Héritage

Object

AuthorizationRule

AccessRule

RegistryAccessRule

Exemples

L’exemple de code suivant illustre les règles d’accès avec héritage et propagation. L’exemple crée un RegistrySecurity objet, puis crée et ajoute deux règles qui ont l’indicateur ContainerInherit . La première règle n’a aucun indicateur de propagation, tandis que la seconde a NoPropagateInherit et InheritOnly.

Le programme affiche les règles dans l’objet RegistrySecurity , puis utilise l’objet pour créer une sous-clé. Le programme crée une sous-clé enfant et une sous-clé petit-enfant, puis affiche la sécurité de chaque sous-clé. Enfin, le programme supprime les clés de test.

using System;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Security;
using Microsoft.Win32;

public class Example
{
    public static void Main()
    {
        const string TestKey = "TestKey3927";
        RegistryKey cu = Registry.CurrentUser;

        string user = Environment.UserDomainName + 
            "\\" + Environment.UserName;

        // Create a security object that grants no access.
        RegistrySecurity mSec = new RegistrySecurity();

        // Add a rule that grants the current user the right
        // to read and enumerate the name/value pairs in a key, 
        // to read its access and audit rules, to enumerate
        // its subkeys, to create subkeys, and to delete the key. 
        // The rule is inherited by all contained subkeys.
        //
        RegistryAccessRule rule = new RegistryAccessRule(user, 
           RegistryRights.ReadKey | RegistryRights.WriteKey 
               | RegistryRights.Delete, 
           InheritanceFlags.ContainerInherit, 
           PropagationFlags.None, 
           AccessControlType.Allow
        );
        mSec.AddAccessRule(rule);

        // Add a rule that allows the current user the right
        // right to set the name/value pairs in a key. 
        // This rule is inherited by contained subkeys, but
        // propagation flags limit it to immediate child 
        // subkeys.
        rule = new RegistryAccessRule(user, 
            RegistryRights.ChangePermissions, 
            InheritanceFlags.ContainerInherit, 
            PropagationFlags.InheritOnly | 
                PropagationFlags.NoPropagateInherit, 
            AccessControlType.Allow);
        mSec.AddAccessRule(rule);

        // Display the rules in the security object.
        ShowSecurity(mSec);

        // Create the test key using the security object.
        //
        RegistryKey rk = cu.CreateSubKey(TestKey, 
            RegistryKeyPermissionCheck.ReadWriteSubTree, mSec);

        // Create a child subkey and a grandchild subkey, 
        // without security.
        RegistryKey rkChild = rk.CreateSubKey("ChildKey", 
            RegistryKeyPermissionCheck.ReadWriteSubTree);
        RegistryKey rkGrandChild = 
            rkChild.CreateSubKey("GrandChildKey", 
                RegistryKeyPermissionCheck.ReadWriteSubTree);

        Show(rk);
        Show(rkChild);
        Show(rkGrandChild);

        rkGrandChild.Close();
        rkChild.Close();
        rk.Close();

        cu.DeleteSubKeyTree(TestKey);
    }

    private static void Show(RegistryKey rk)
    {
        Console.WriteLine(rk.Name);
        ShowSecurity(rk.GetAccessControl());
    }

    private static void ShowSecurity(RegistrySecurity security)
    {
        Console.WriteLine("\r\nCurrent access rules:\r\n");

        foreach( RegistryAccessRule ar in security.GetAccessRules(true, true, typeof(NTAccount)) )
        {

            Console.WriteLine("        User: {0}", ar.IdentityReference);
            Console.WriteLine("        Type: {0}", ar.AccessControlType);
            Console.WriteLine("      Rights: {0}", ar.RegistryRights);
            Console.WriteLine(" Inheritance: {0}", ar.InheritanceFlags);
            Console.WriteLine(" Propagation: {0}", ar.PropagationFlags);
            Console.WriteLine("   Inherited? {0}", ar.IsInherited);
            Console.WriteLine();
        }
    }
}

/* This code example produces output similar to following:

Current access rules:

        User: TestDomain\TestUser
        Type: Allow
      Rights: SetValue, CreateSubKey, Delete, ReadKey
 Inheritance: ContainerInherit
 Propagation: None
   Inherited? False

        User: TestDomain\TestUser
        Type: Allow
      Rights: ChangePermissions
 Inheritance: ContainerInherit
 Propagation: NoPropagateInherit, InheritOnly
   Inherited? False

HKEY_CURRENT_USER\TestKey3927

Current access rules:

        User: TestDomain\TestUser
        Type: Allow
      Rights: SetValue, CreateSubKey, Delete, ReadKey
 Inheritance: ContainerInherit
 Propagation: None
   Inherited? False

        User: TestDomain\TestUser
        Type: Allow
      Rights: ChangePermissions
 Inheritance: ContainerInherit
 Propagation: NoPropagateInherit, InheritOnly
   Inherited? False

HKEY_CURRENT_USER\TestKey3927\ChildKey

Current access rules:

        User: TestDomain\TestUser
        Type: Allow
      Rights: SetValue, CreateSubKey, Delete, ReadKey
 Inheritance: ContainerInherit
 Propagation: None
   Inherited? True

        User: TestDomain\TestUser
        Type: Allow
      Rights: ChangePermissions
 Inheritance: None
 Propagation: None
   Inherited? True

HKEY_CURRENT_USER\TestKey3927\ChildKey\GrandChildKey

Current access rules:

        User: TestDomain\TestUser
        Type: Allow
      Rights: SetValue, CreateSubKey, Delete, ReadKey
 Inheritance: ContainerInherit
 Propagation: None
   Inherited? True
 */

Option Explicit
Imports System.Security.AccessControl
Imports System.Security.Principal
Imports System.Security
Imports Microsoft.Win32

Public Class Example

    Public Shared Sub Main()

        Const TestKey As String = "TestKey3927"
        Dim cu As RegistryKey = Registry.CurrentUser

        Dim user As String = Environment.UserDomainName _ 
            & "\" & Environment.UserName

        ' Create a security object that grants no access.
        Dim mSec As New RegistrySecurity()

        ' Add a rule that grants the current user the right
        ' to read and enumerate the name/value pairs in a key, 
        ' to read its access and audit rules, to enumerate
        ' its subkeys, to create subkeys, and to delete the key. 
        ' The rule is inherited by all contained subkeys.
        '
        Dim rule As New RegistryAccessRule(user, _
            RegistryRights.ReadKey Or RegistryRights.WriteKey _
                Or RegistryRights.Delete, _
            InheritanceFlags.ContainerInherit, _
            PropagationFlags.None, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ' Add a rule that allows the current user the right
        ' right to set the name/value pairs in a key. 
        ' This rule is inherited by contained subkeys, but
        ' propagation flags limit it to immediate child 
        ' subkeys.
        rule = New RegistryAccessRule(user, _
            RegistryRights.ChangePermissions, _
            InheritanceFlags.ContainerInherit, _
            PropagationFlags.InheritOnly Or PropagationFlags.NoPropagateInherit, _
            AccessControlType.Allow)
        mSec.AddAccessRule(rule)

        ' Display the rules in the security object.
        ShowSecurity(mSec)

        ' Create the test key using the security object.
        '
        Dim rk As RegistryKey = cu.CreateSubKey(TestKey, _
            RegistryKeyPermissionCheck.ReadWriteSubTree, _
            mSec)

        ' Create a child subkey and a grandchild subkey, 
        ' without security.
        Dim rkChild As RegistryKey= rk.CreateSubKey("ChildKey", _
            RegistryKeyPermissionCheck.ReadWriteSubTree)
        Dim rkGrandChild As RegistryKey = _
            rkChild.CreateSubKey("GrandChildKey", _
                RegistryKeyPermissionCheck.ReadWriteSubTree)

        Show(rk)
        Show(rkChild)
        Show(rkGrandChild)

        rkGrandChild.Close()
        rkChild.Close()
        rk.Close()

        cu.DeleteSubKeyTree(TestKey)
    End Sub 

    Private Shared Sub Show(ByVal rk As RegistryKey)
        Console.WriteLine(rk.Name)            
        ShowSecurity(rk.GetAccessControl())
    End Sub

    Private Shared Sub ShowSecurity(ByVal security As RegistrySecurity)
        Console.WriteLine(vbCrLf & "Current access rules:" & vbCrLf)

        For Each ar As RegistryAccessRule In _
            security.GetAccessRules(True, True, GetType(NTAccount))

            Console.WriteLine("        User: {0}", ar.IdentityReference)
            Console.WriteLine("        Type: {0}", ar.AccessControlType)
            Console.WriteLine("      Rights: {0}", ar.RegistryRights)
            Console.WriteLine(" Inheritance: {0}", ar.InheritanceFlags)
            Console.WriteLine(" Propagation: {0}", ar.PropagationFlags)
            Console.WriteLine("   Inherited? {0}", ar.IsInherited)
            Console.WriteLine()
        Next

    End Sub
End Class 

'This code example produces output similar to following:
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: SetValue, CreateSubKey, Delete, ReadKey
' Inheritance: ContainerInherit
' Propagation: None
'   Inherited? False
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: ChangePermissions
' Inheritance: ContainerInherit
' Propagation: NoPropagateInherit, InheritOnly
'   Inherited? False
'
'HKEY_CURRENT_USER\TestKey3927
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: SetValue, CreateSubKey, Delete, ReadKey
' Inheritance: ContainerInherit
' Propagation: None
'   Inherited? False
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: ChangePermissions
' Inheritance: ContainerInherit
' Propagation: NoPropagateInherit, InheritOnly
'   Inherited? False
'
'HKEY_CURRENT_USER\TestKey3927\ChildKey
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: SetValue, CreateSubKey, Delete, ReadKey
' Inheritance: ContainerInherit
' Propagation: None
'   Inherited? True
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: ChangePermissions
' Inheritance: None
' Propagation: None
'   Inherited? True
'
'HKEY_CURRENT_USER\TestKey3927\ChildKey\GrandChildKey
'
'Current access rules:
'
'        User: TestDomain\TestUser
'        Type: Allow
'      Rights: SetValue, CreateSubKey, Delete, ReadKey
' Inheritance: ContainerInherit
' Propagation: None
'   Inherited? True

Remarques

La RegistryAccessRule classe est l’un des ensembles de classes que le .NET Framework fournit pour gérer la sécurité du contrôle d’accès Windows sur les clés de Registre. Pour obtenir une vue d’ensemble de ces classes et de leur relation avec les structures de contrôle d’accès Windows sous-jacentes, consultez RegistrySecurity.

Notes

La sécurité du contrôle d’accès Windows ne peut être appliquée qu’aux clés de Registre. Il ne peut pas être appliqué à des paires clé/valeur individuelles stockées dans une clé.

Pour obtenir la liste des règles actuellement appliquées à une clé de Registre, utilisez la RegistryKey.GetAccessControl méthode pour obtenir un RegistrySecurity objet, puis utilisez sa GetAccessRules méthode pour obtenir une collection d’objets RegistryAccessRule .

RegistryAccessRule Les objets ne sont pas mappés un-à-un avec les entrées de contrôle d’accès dans la liste d’accès de contrôle discrétionnaire (DACL) sous-jacente. Lorsque vous obtenez l’ensemble de toutes les règles d’accès pour une clé de Registre, le jeu contient le nombre minimal de règles actuellement requises pour exprimer toutes les entrées de contrôle d’accès.

Notes

Les entrées de contrôle d’accès sous-jacentes changent à mesure que vous appliquez et supprimez des règles. Les informations contenues dans les règles sont fusionnées si possible pour conserver le plus petit nombre d’entrées de contrôle d’accès. Par conséquent, lorsque vous lisez la liste actuelle des règles, il se peut qu’elle ne ressemble pas exactement à la liste de toutes les règles que vous avez ajoutées.

Utilisez des RegistryAccessRule objets pour spécifier les droits d’accès à autoriser ou refuser à un utilisateur ou un groupe. Un RegistryAccessRule objet représente toujours l’accès autorisé ou l’accès refusé, jamais les deux.

Pour appliquer une règle à une clé de Registre, utilisez la RegistryKey.GetAccessControl méthode pour obtenir l’objet RegistrySecurity . Modifiez l’objet à l’aide RegistrySecurity de ses méthodes pour ajouter la règle, puis utilisez la RegistryKey.SetAccessControl méthode pour rattacher l’objet de sécurité.

Important

Les modifications que vous apportez à un RegistrySecurity objet n’affectent pas les niveaux d’accès de la clé de Registre tant que vous n’appelez pas la RegistryKey.SetAccessControl méthode pour affecter l’objet de sécurité modifié à la clé de Registre.

RegistryAccessRule les objets sont immuables. La sécurité d’une clé de Registre est modifiée à l’aide des méthodes de la RegistrySecurity classe pour ajouter ou supprimer des règles ; dans ce cas, les entrées de contrôle d’accès sous-jacentes sont modifiées.

Constructeurs

RegistryAccessRule(IdentityReference, RegistryRights, AccessControlType)	Initialise une nouvelle instance de la classe RegistryAccessRule, en spécifiant l'utilisateur ou le groupe auquel la règle s'applique, les droits d'accès, et si les droits d'accès spécifiés sont accordés ou refusés.
RegistryAccessRule(IdentityReference, RegistryRights, InheritanceFlags, PropagationFlags, AccessControlType)	Initialise une nouvelle instance de la classe RegistryAccessRule, en spécifiant l'utilisateur ou le groupe auquel la règle s'applique, les droits d'accès, les indicateurs d'héritage, les indicateurs de propagation et si ces droits d'accès sont accordés ou refusés.
RegistryAccessRule(String, RegistryRights, AccessControlType)	Initialise une nouvelle instance de la classe RegistryAccessRule, en spécifiant le nom de l'utilisateur ou du groupe auquel la règle s'applique, les droits d'accès, et si les droits d'accès spécifiés sont accordés ou refusés.
RegistryAccessRule(String, RegistryRights, InheritanceFlags, PropagationFlags, AccessControlType)	Initialise une nouvelle instance de la classe RegistryAccessRule, en spécifiant le nom de l'utilisateur ou du groupe auquel la règle s'applique, les droits d'accès, les indicateurs d'héritage, les indicateurs de propagation et si ces droits d'accès sont accordés ou refusés.

Propriétés

AccessControlType	Obtient la valeur AccessControlType associée à cet objet AccessRule. (Hérité de AccessRule)
AccessMask	Obtient le masque d’accès de cette règle. (Hérité de AuthorizationRule)
IdentityReference	Obtient l’objet IdentityReference auquel cette règle s’applique. (Hérité de AuthorizationRule)
InheritanceFlags	Obtient la valeur des indicateurs qui déterminent comment cette règle est héritée par les objets enfants. (Hérité de AuthorizationRule)
IsInherited	Obtient une valeur qui indique si cette règle est explicitement définie ou héritée d’un objet de conteneur parent. (Hérité de AuthorizationRule)
PropagationFlags	Obtient la valeur des indicateurs de propagation, qui déterminent la façon dont l’héritage de cette règle est propagée aux objets enfants. Cette propriété est significative uniquement lorsque la valeur de l’énumération InheritanceFlags n’est pas None. (Hérité de AuthorizationRule)
RegistryRights	Obtient les droits accordés ou refusés par la règle d'accès.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
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)
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)