Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Costruttore RegistryAccessRule (String, RegistryRights, InheritanceFlags, PropagationFlags, AccessControlType)

 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza di RegistryAccessRule classe, specificando il nome dell'utente o del gruppo viene applicata la regola, i diritti di accesso, i flag di ereditarietà, i flag di propagazione e se i diritti di accesso sono consentiti o negati.

Spazio dei nomi:   System.Security.AccessControl
Assembly:  mscorlib (in mscorlib.dll)

public RegistryAccessRule(
	string identity,
	RegistryRights registryRights,
	InheritanceFlags inheritanceFlags,
	PropagationFlags propagationFlags,
	AccessControlType type
)

Parametri

identity
Type: System.String

Il nome dell'utente o del gruppo viene applicata la regola.

registryRights
Type: System.Security.AccessControl.RegistryRights

Una combinazione bit per bit di RegistryRights valori che indicano i diritti concessi o negati.

inheritanceFlags
Type: System.Security.AccessControl.InheritanceFlags

Una combinazione bit per bit di InheritanceFlags flag che specificano come diritti di accesso vengono ereditati da altri oggetti.

propagationFlags
Type: System.Security.AccessControl.PropagationFlags

Una combinazione bit per bit di PropagationFlags flag che specificano la modalità di propagazione dei diritti di accesso ad altri oggetti.

type
Type: System.Security.AccessControl.AccessControlType

Uno del AccessControlType valori che specificano se i diritti sono concesse o negati.

Exception Condition
ArgumentOutOfRangeException

registryRights Specifica un valore non valido.

-oppure-

type Specifica un valore non valido.

-oppure-

inheritanceFlags Specifica un valore non valido.

-oppure-

propagationFlags Specifica un valore non valido.

ArgumentNullException

eventRights è uguale a zero.

ArgumentException

identity è null.

-oppure-

identity è una stringa di lunghezza zero.

-oppure-

identity è più di 512 caratteri.

Tutte le chiavi del Registro di sistema sono contenitori, pertanto è l'unico flag di ereditarietà che è significativo per le chiavi del Registro di sistema di InheritanceFlags.ContainerInherit flag. Se questo flag non è specificato, i flag di propagazione vengono ignorati, ed è interessata solo la chiave immediata. Se il flag è presente, la regola viene propagata come illustrato nella tabella seguente. Nella tabella si presuppone che vi sia una sottochiave S con sottochiave figlia CS e sottochiave nipote GS. Ovvero, il percorso della sottochiave nipote è S\CS\GS..

Flag di propagazione

S

CS

GS

None

X

X

X

NoPropagateInherit

X

X

 

InheritOnly

 

X

X

NoPropagateInherit, InheritOnly

 

X

 

Il modello della sottochiave nipote regola tutte le sottochiavi in essa contenute.

Ad esempio, se il ContainerInherit viene specificato il flag inheritanceFlags e InheritOnly viene specificato il flag di propagazione propagationFlags, questa regola non si applica alla sottochiave immediata, ma si applicano a tutte le relative sottochiavi figlio immediati e a tutte le sottochiavi contengono.

System_CAPS_noteNota

Sebbene sia possibile specificare il InheritanceFlags.ObjectInherit flag per inheritanceFlags, è inutile in questo modo. Ai fini di controllo di accesso, le coppie nome/valore in una sottochiave non sono oggetti separati. Diritti di accesso alle coppie nome/valore sono controllati dai diritti della sottochiave. Inoltre, poiché tutte le sottochiavi sono contenitori (vale a dire possono contenere altre sottochiavi), non vengono influenzati dal ObjectInherit flag. Infine, se si specifica il ObjectInherit flag complica inutilmente la gestione delle regole, perché interferisce con la combinazione di regole altrimenti compatibili.

Questo costruttore è equivalente alla creazione di un NTAccount oggetto, passando identity per il NTAccount.NTAccount(String) costruttore e passando l'oggetto appena creato NTAccount dell'oggetto per il RegistryAccessRule(IdentityReference, RegistryRights, InheritanceFlags, PropagationFlags, AccessControlType) costruttore.

Esempio di codice riportato di seguito viene illustrato come le regole di accesso con ereditarietà e propagazione. Nell'esempio viene creato un RegistrySecurity dell'oggetto, quindi crea e aggiunge due regole che dispongono di ContainerInherit flag. La prima regola non dispone di alcun flag di propagazione, mentre il secondo contiene NoPropagateInherit e InheritOnly.

Il programma visualizza le regole di RegistrySecurity oggetto e quindi viene utilizzato il RegistrySecurity oggetto per creare una sottochiave. Il programma crea un elemento figlio sottochiave e una sottochiave nipote e quindi Visualizza le regole per ogni sottochiave. Infine, il programma consente di eliminare le chiavi di prova.


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
 */

.NET Framework
Disponibile da 2.0
Torna all'inizio
Mostra: