Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

RegistryKey.SetAccessControl-Methode: (RegistrySecurity)

 

Veröffentlicht: Oktober 2016

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

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

public void SetAccessControl(
	RegistrySecurity registrySecurity
)

Parameter

registrySecurity
Type: System.Security.AccessControl.RegistrySecurity

Die Zugriffssteuerungssicherheit, die für den aktuellen Unterschlüssel angewendet werden soll.

Exception Condition
UnauthorizedAccessException

Die aktuelle RegistryKey Objekt stellt einen Schlüssel dar, mit der Steuerung des Zugriffs und der Aufrufer verfügt nicht über RegistryRights.ChangePermissions Rechte.

ArgumentNullException

registrySecurity ist null.

ObjectDisposedException

Die RegistryKey das manipuliert wird geschlossen (auf geschlossene Schlüssel können nicht zugegriffen werden).

Verwenden, um Berechtigungen für einen Registrierungsschlüssel ändern die GetAccessControl -Methode erhalten ein RegistrySecurity Objekt, das die vorhandenen Windows-zugriffssteuerungssicherheit darstellt, zu ändern, die RegistrySecurity Objekt, und verwenden Sie dann die SetAccessControl Methode, um die Sicherheit für den Schlüssel zu aktualisieren.

System_CAPS_cautionAchtung

Die RegistrySecurity für angegebene Objekt registrySecurity ersetzt die vorhandene Sicherheit für den Registrierungsschlüssel. Um Berechtigungen für einen neuen Benutzer hinzuzufügen, verwenden Sie die GetAccessControl -Methode zum Abrufen des vorhandenen Zugriffs Steuern der Sicherheit und anschließend zu ändern.

Das folgende Codebeispiel erstellt einen Testschlüssel. Der aktuelle Benutzer ReadKey und Delete Rechte jedoch verweigert ChangePermissions und WriteKey Rechte. Nachfolgende versucht, erfolgreich oder Fehler in Abhängigkeit von diesen Berechtigungen.

Bevor der Schlüssel gelöscht wird, wird der Code angehalten. Wechseln Sie zu den Registrierungs-Editor, und stellen Sie sicher, dass die gleichen Zugriffsrechte angewendet werden, wenn der Zugriff auf den Schlüssel im Registrierungs-Editor ist. (Dies funktioniert am besten, wenn Sie verwenden "runas" über die Befehlszeile den Registrierungs-Editor und der Beispielcode als lokaler Benutzer ohne Administratorrechte ausführen. Registrierungs-Editor kann immer ein Administrator Berechtigungen ändern, auch wenn der Administrator bestimmte Rechte verweigert wurde. Wenn Sie einen lokalen Benutzer namens "testuser", mit dem Befehl definiert haben runas /user:TestUser cmd Öffnet ein Befehlsfenster auf dem Sie den Registrierungseditor, und klicken Sie dann 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
Verfügbar seit 2.0
Zurück zum Anfang
Anzeigen: