(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

RegistryKey.SetAccessControl-Methode

Übernimmt Windows-Zugriffssteuerungssicherheit für einen vorhandenen Registrierungsschlüssel.

Namespace:  Microsoft.Win32
Assembly:  mscorlib (in mscorlib.dll)

public void SetAccessControl(
	RegistrySecurity registrySecurity
)

Parameter

registrySecurity
Typ: System.Security.AccessControl.RegistrySecurity
Die Zugriffssteuerungssicherheit, die für den aktuellen Unterschlüssel angewendet werden soll.

AusnahmeBedingung
UnauthorizedAccessException

Das aktuelle RegistryKey-Objekt stellt einen Schlüssel mit Zugriffssteuerungssicherheit dar, und der Aufrufer verfügt nicht über RegistryRights.ChangePermissions-Rechte.

ArgumentNullException

registrySecurity ist null.

ObjectDisposedException

Der zu bearbeitende RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

Um Berechtigungen für einen Registrierungsschlüssel zu ändern, rufen Sie mithilfe der GetAccessControl-Methode ein RegistrySecurity-Objekt ab, das die vorhandene Windows-Zugriffssteuerungssicherheit darstellt. Ändern Sie dieses RegistrySecurity-Objekt, und verwenden Sie anschließend die SetAccessControl-Methode, um die Sicherheit für den Schlüssel zu aktualisieren.

WarnhinweisVorsicht

Das für registrySecurity angegebene RegistrySecurity-Objekt ersetzt die vorhandene Sicherheit für den Registrierungsschlüssel. Um Berechtigungen für einen neuen Benutzer hinzuzufügen, rufen Sie die vorhandene Zugriffssteuerungssicherheit mithilfe der GetAccessControl-Methode ab, und ändern Sie die Zugriffssteuerungssicherheit.

Im folgenden Codebeispiel wird ein Testschlüssel erstellt. Für den aktuellen Benutzer sind ReadKey-Rechte und Delete-Rechte zulässig, dagegen werden ChangePermissions-Rechte und WriteKey-Rechte verweigert. Je nach Berechtigungen sind nachfolgende Schlüsselbearbeitungsversuche erfolgreich oder scheitern.

Bevor der Schlüssel gelöscht wird, hält der Code an. Sie können zum Registrierungs-Editor wechseln und überprüfen, ob dieselben Zugriffsrechte gelten, wenn der Zugriff auf den Schlüssel mithilfe des Registrierungs-Editors erfolgt. (Geben Sie dazu am besten als lokaler Benutzer ohne Administratorrechte in der Befehlszeile RunAs ein, um den Registrierungs-Editor aufzurufen, und führen Sie den Beispielcode aus. Im Registrierungs-Editor kann ein Administrator jederzeit Berechtigungen ändern, sogar dann, wenn dem jeweiligen Administrator die entsprechenden Rechte verweigert worden sind. Wenn Sie einen lokalen Benutzer mit dem Namen TestUser definiert haben, öffnet der Befehl runas /user:TestUser cmd ein Befehlsfenster, über das Sie den Registrierungs-Editor aufrufen und anschließend den Beispielcode ausführen können.)


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


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft