RegistryRights Výčet

Definice

Obor názvů:

System.Security.AccessControl

Sestavení:

Microsoft.Win32.Registry.dll

Určuje práva řízení přístupu, která lze použít pro objekty registru.

Tento výčet podporuje bitové kombinace hodnot jeho členů.

public enum class RegistryRights

[System.Flags]
public enum RegistryRights

[<System.Flags>]
type RegistryRights = 

Public Enum RegistryRights

Dědičnost

Object

ValueType

Enum

RegistryRights

Atributy

FlagsAttribute

Pole

Name	Hodnota	Description
QueryValues	1	Právo dotazovat se na páry název/hodnota v klíči registru.
SetValue	2	Právo vytvořit, odstranit nebo nastavit páry název/hodnota v klíči registru.
CreateSubKey	4	Právo vytvořit podklíče klíče registru.
EnumerateSubKeys	8	Právo vypsat podklíče klíče registru.
Notify	16	Právo požadovat oznámení o změnách klíče registru.
CreateLink	32	Vyhrazeno pro systémové použití.
Delete	65536	Právo odstranit klíč registru.
ReadPermissions	131072	Právo otevřít a zkopírovat pravidla přístupu a pravidla auditu pro klíč registru.
WriteKey	131078	Právo na vytvoření, odstranění a nastavení párů název/hodnota v klíči registru, vytvoření nebo odstranění podklíčů, vyžádání oznámení o změnách, vytvoření výčtu jeho podklíčů a čtení přístupových pravidel a pravidel auditu.
ExecuteKey	131097	Stejné jako ReadKey.
ReadKey	131097	Právo dotazovat se na páry název/hodnota v klíči registru, požadovat oznámení změn, vytvořit výčet jeho podklíčů a číst pravidla přístupu a pravidla auditu.
ChangePermissions	262144	Právo změnit pravidla přístupu a pravidla auditu přidružená k klíči registru.
TakeOwnership	524288	Právo změnit vlastníka klíče registru.
FullControl	983103	Právo na plnou kontrolu nad klíčem registru a úpravou přístupových pravidel a pravidel auditu.

Příklady

Následující příklad kódu ukazuje použití výčtu RegistryRights . Kód vytvoří testovací klíč, který umožňuje aktuálnímu uživateli readkey a odstranit přístupová práva, ale odepře oprávnění ChangePermissions a WriteKey. Následné pokusy o manipulaci s klíčem jsou úspěšné nebo neúspěšné v závislosti na těchto oprávněních.

Před odstraněním klíče se kód pozastaví. Můžete přepnout do Editoru registru (Regedit.exe nebo Regedt32.exe) a ověřit, že se stejná přístupová práva vztahují při přístupu ke klíči pomocí Editoru registru.

Tento příklad funguje nejlépe, pokud ke spuštění Editoru registru a ukázkového kódu jako místního uživatele bez oprávnění správce použijete RunAs z příkazového řádku. Pokud jste například definovali místního uživatele s názvem TestUser, příkaz runas /user:TestUser cmd otevře příkazové okno, ze kterého můžete spustit Editor registru a pak ukázkový kód.

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

public class Example
{
    public static void Main()
    {
        // Delete the example key if it exists.
        try
        {
            Registry.CurrentUser.DeleteSubKey("RegistryRightsExample");
            Console.WriteLine("Example key has been deleted.");
        }
        catch (ArgumentException)
        {
            // ArgumentException is thrown if the key does not exist. In
            // this case, there is no reason to display a message.
        }
        catch (Exception ex)
        {
            Console.WriteLine("Unable to delete the example key: {0}", ex);
            return;
        }

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

        RegistrySecurity rs = new RegistrySecurity();

        // Allow the current user to read and delete the key.
        //
        rs.AddAccessRule(new RegistryAccessRule(user,
            RegistryRights.ReadKey | RegistryRights.Delete,
            InheritanceFlags.None,
            PropagationFlags.None,
            AccessControlType.Allow));

        // Prevent the current user from writing or changing the
        // permission set of the key. Note that if Delete permission
        // were not allowed in the previous access rule, denying
        // WriteKey permission would prevent the user from deleting the
        // key.
        rs.AddAccessRule(new RegistryAccessRule(user,
            RegistryRights.WriteKey | RegistryRights.ChangePermissions,
            InheritanceFlags.None,
            PropagationFlags.None,
            AccessControlType.Deny));

        // Create the example key with registry security.
        RegistryKey rk = null;
        try
        {
            rk = Registry.CurrentUser.CreateSubKey("RegistryRightsExample",
                RegistryKeyPermissionCheck.Default, rs);
            Console.WriteLine("\r\nExample key created.");
            rk.SetValue("ValueName", "StringValue");
        }
        catch (Exception ex)
        {
            Console.WriteLine("\r\nUnable to create the example key: {0}", ex);
        }
        if (rk != null) rk.Close();

        rk = Registry.CurrentUser;

        RegistryKey rk2;

        // Open the key with read access.
        rk2 = rk.OpenSubKey("RegistryRightsExample", false);
        Console.WriteLine("\r\nRetrieved value: {0}", rk2.GetValue("ValueName"));
        rk2.Close();

        // Attempt to open the key with write access.
        try
        {
            rk2 = rk.OpenSubKey("RegistryRightsExample", true);
        }
        catch (SecurityException ex)
        {
            Console.WriteLine("\nUnable to write to the example key." +
                " Caught SecurityException: {0}", ex.Message);
        }
        if (rk2 != null) rk2.Close();

        // Attempt to change permissions for the key.
        try
        {
            rs = new RegistrySecurity();
            rs.AddAccessRule(new RegistryAccessRule(user,
                RegistryRights.WriteKey,
                InheritanceFlags.None,
                PropagationFlags.None,
                AccessControlType.Allow));
            rk2 = rk.OpenSubKey("RegistryRightsExample", false);
            rk2.SetAccessControl(rs);
            Console.WriteLine("\r\nExample key permissions were changed.");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine("\nUnable to change permissions for the example key." +
                " Caught UnauthorizedAccessException: {0}", ex.Message);
        }
        if (rk2 != null) rk2.Close();

        Console.WriteLine("\r\nPress Enter to delete the example key.");
        Console.ReadLine();

        try
        {
            rk.DeleteSubKey("RegistryRightsExample");
            Console.WriteLine("Example key was deleted.");
        }
        catch(Exception ex)
        {
            Console.WriteLine("Unable to delete the example key: {0}", ex);
        }

        rk.Close();
    }
}

/* This code example produces the following output:

Example key created.

Retrieved value: StringValue

Unable to write to the example key. Caught SecurityException: Requested registry access is not allowed.

Unable to change permissions for the example key. Caught UnauthorizedAccessException: Cannot write to the registry key.

Press Enter to delete the example key.

Example key was deleted.
 */

Imports System.Reflection
Imports System.Security
Imports System.Security.AccessControl
Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete the example key if it exists.
        Try
            Registry.CurrentUser.DeleteSubKey("RegistryRightsExample")
            Console.WriteLine("Example key has been deleted.")
        Catch ex As ArgumentException
            ' ArgumentException is thrown if the key does not exist. In
            ' this case, there is no reason to display a message.
        Catch ex As Exception
            Console.WriteLine("Unable to delete the example key: {0}", ex)
            Return
        End Try

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

        Dim rs As New RegistrySecurity()

        ' Allow the current user to read and delete the key.
        '
        rs.AddAccessRule(new RegistryAccessRule(user, _
            RegistryRights.ReadKey Or RegistryRights.Delete, _
            InheritanceFlags.None, _
            PropagationFlags.None, _
            AccessControlType.Allow))

        ' Prevent the current user from writing or changing the
        ' permission set of the key. Note that if Delete permission
        ' were not allowed in the previous access rule, denying
        ' WriteKey permission would prevent the user from deleting the 
        ' key.
        rs.AddAccessRule(new RegistryAccessRule(user, _
            RegistryRights.WriteKey Or RegistryRights.ChangePermissions, _
            InheritanceFlags.None, _
            PropagationFlags.None, _
            AccessControlType.Deny))

        ' Create the example key with registry security.
        Dim rk As RegistryKey = Nothing
        Try
            rk = Registry.CurrentUser.CreateSubKey("RegistryRightsExample", _
                RegistryKeyPermissionCheck.Default, rs)
            Console.WriteLine(vbCrLf & "Example key created.")
            rk.SetValue("ValueName", "StringValue")
        Catch ex As Exception
            Console.WriteLine(vbCrLf & "Unable to create the example key: {0}", ex)
        End Try

        If rk IsNot Nothing Then rk.Close()

        rk = Registry.CurrentUser

        Dim rk2 As RegistryKey
        
        ' Open the key with read access.
        rk2 = rk.OpenSubKey("RegistryRightsExample", False)
        Console.WriteLine(vbCrLf & "Retrieved value: {0}", rk2.GetValue("ValueName"))
        rk2.Close()

        ' Attempt to open the key with write access.
        Try
            rk2 = rk.OpenSubKey("RegistryRightsExample", True)
        Catch ex As SecurityException
            Console.WriteLine(vbCrLf & "Unable to write to the example key." _
                & " Caught SecurityException: {0}", ex.Message)
        End Try
        If rk2 IsNot Nothing Then rk2.Close()

        ' Attempt to change permissions for the key.
        Try
            rs = New RegistrySecurity()
            rs.AddAccessRule(new RegistryAccessRule(user, _
                RegistryRights.WriteKey, _
                InheritanceFlags.None, _
                PropagationFlags.None, _
                AccessControlType.Allow))
            rk2 = rk.OpenSubKey("RegistryRightsExample", False)
            rk2.SetAccessControl(rs)
            Console.WriteLine(vbCrLf & "Example key permissions were changed.")
        Catch ex As UnauthorizedAccessException
            Console.WriteLine(vbCrLf & "Unable to change permissions for the example key." _
                & " Caught UnauthorizedAccessException: {0}", ex.Message)
        End Try
        If rk2 IsNot Nothing Then rk2.Close()

        Console.WriteLine(vbCrLf & "Press Enter to delete the example key.")
        Console.ReadLine()

        Try
            rk.DeleteSubKey("RegistryRightsExample")
            Console.WriteLine("Example key was deleted.")
        Catch ex As Exception
            Console.WriteLine("Unable to delete the example key: {0}", ex)
        End Try

        rk.Close()
    End Sub
End Class

' This code produces the following output:
'
'Example key created.
'
'Retrieved value: StringValue
'
'Unable to write to the example key. Caught SecurityException: Requested registry access is not allowed.
'
'Unable to change permissions for the example key. Caught UnauthorizedAccessException: Cannot write to the registry key.
'
'Press Enter to delete the example key.
'
'Example key was deleted.

Poznámky

Výčet RegistryRights použijte k určení přístupových práv registru při vytváření RegistrySecurity objektů. Chcete-li použít přístupová práva na klíč registru, nejprve přidejte RegistryAccessRule objekty do RegistrySecurity objektu, pak objekt připojte RegistrySecurity ke klíči pomocí RegistryKey.SetAccessControl metody nebo odpovídající přetížení RegistryKey.CreateSubKey metody.

Viz také

• RegistryAccessRule
• RegistrySecurity
• RegistryAuditRule