RegistryRights Enumeración
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Especifica los derechos de control de acceso que se pueden aplicar a los objetos del Registro.
Esta enumeración admite una combinación bit a bit de sus valores de miembro.
public enum class RegistryRights[System.Flags]
public enum RegistryRights[<System.Flags>]
type RegistryRights = Public Enum RegistryRights- Herencia
- Atributos
Campos
| ChangePermissions | 262144 | El derecho a cambiar las reglas de acceso y de auditoría asociadas a una clave del Registro. |
| CreateLink | 32 | Reservado para uso del sistema. |
| CreateSubKey | 4 | El derecho a crear subclaves de una clave del Registro. |
| Delete | 65536 | El derecho a eliminar una clave del Registro. |
| EnumerateSubKeys | 8 | El derecho a mostrar las subclaves de una clave del Registro. |
| ExecuteKey | 131097 | Igual a ReadKey. |
| FullControl | 983103 | Derecho a ejercer el control completo sobre una clave del Registro y a modificar las reglas de acceso y de auditoría. |
| Notify | 16 | El derecho a solicitar notificación de cambios sobre una clave del Registro. |
| QueryValues | 1 | El derecho a consultar los pares de nombre/valor en una clave del Registro. |
| ReadKey | 131097 | El derecho a consultar los pares de nombre/valor en una clave del Registro, solicitar notificación de cambios, enumerar las subclaves y leer las reglas de acceso y de auditoría. |
| ReadPermissions | 131072 | Derecho a abrir y copiar las reglas de acceso y de auditoría para una clave del Registro. |
| SetValue | 2 | El derecho a crear, eliminar o establecer pares de nombre/valor en una clave del Registro. |
| TakeOwnership | 524288 | El derecho a cambiar el propietario de una clave del Registro. |
| WriteKey | 131078 | El derecho a crear, eliminar y establecer los pares de nombre/valor en una clave del Registro, crear o eliminar las subclaves, solicitar notificación de cambios, enumerar las subclaves y leer las reglas de acceso y de auditoría. |
Ejemplos
En el ejemplo de código siguiente se muestra el uso de la RegistryRights enumeración . El código crea una clave de prueba, lo que permite al usuario actual derechos de acceso ReadKey y Delete, pero deniega los derechos ChangePermissions y WriteKey. Los intentos posteriores de manipular la clave se realizan correctamente o producen un error en función de estos permisos.
Antes de eliminar la clave, el código se detiene. Puede cambiar al Editor del Registro (Regedit.exe o Regedt32.exe) y comprobar que se aplican los mismos derechos de acceso cuando se accede a la clave mediante el Editor del Registro.
Este ejemplo funciona mejor si usa RunAs desde la línea de comandos para ejecutar el Editor del Registro y el código de ejemplo como usuario local sin derechos de administrador. Por ejemplo, si ha definido un usuario local denominado TestUser, el comando runas /user:TestUser cmd abre una ventana de comandos desde la que puede ejecutar el Editor del Registro y, a continuación, el código de ejemplo.
using namespace System;
using namespace System::Reflection;
using namespace Microsoft::Win32;
using namespace System::Security::AccessControl;
using namespace System::Security;
int 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 (InvalidOperationException^ ex)
{
Console::WriteLine(
"{0}Unable to delete key: it appears to have child subkeys:{0}{1}",
Environment::NewLine, ex);
return 0;
}
catch (SecurityException^ ex)
{
Console::WriteLine("{0}You do not have the permissions required " +
"to delete this key:{0}{1}", Environment::NewLine, ex);
return 0;
}
String^ user = Environment::UserDomainName + "\\" + Environment::UserName;
RegistrySecurity^ regSecurity = gcnew RegistrySecurity();
// Allow the current user to read and delete the key.
//
regSecurity->AddAccessRule(gcnew 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.
regSecurity->AddAccessRule(gcnew RegistryAccessRule(user,
RegistryRights::WriteKey | RegistryRights::ChangePermissions,
InheritanceFlags::None,
PropagationFlags::None,
AccessControlType::Deny));
// Create the example key with registry security.
RegistryKey^ createdKey = nullptr;
try
{
createdKey = Registry::CurrentUser->CreateSubKey(
"RegistryRightsExample", RegistryKeyPermissionCheck::Default,
regSecurity);
Console::WriteLine("{0}Example key created.", Environment::NewLine);
createdKey->SetValue("ValueName", "StringValue");
}
catch (SecurityException^ ex)
{
Console::WriteLine("{0}You do not have the permissions required " +
"to create the example key:{0}{1}", Environment::NewLine, ex);
return 0;
}
if (createdKey != nullptr)
{
createdKey->Close();
}
RegistryKey^ openedKey;
// Open the key with read access.
openedKey = Registry::CurrentUser->OpenSubKey("RegistryRightsExample",
false);
Console::WriteLine("{0}Retrieved value: {1}",
Environment::NewLine, openedKey->GetValue("ValueName"));
openedKey->Close();
// Attempt to open the key with write access.
try
{
openedKey = Registry::CurrentUser->OpenSubKey("RegistryRightsExample",
true);
}
catch (SecurityException^ ex)
{
Console::WriteLine("{0}You do not have the permissions required " +
"to write to the example key:{0}{1}", Environment::NewLine, ex);
}
if (openedKey != nullptr)
{
openedKey->Close();
}
// Attempt to change permissions for the key.
try
{
regSecurity = gcnew RegistrySecurity();
regSecurity->AddAccessRule(gcnew RegistryAccessRule(user,
RegistryRights::WriteKey,
InheritanceFlags::None,
PropagationFlags::None,
AccessControlType::Allow));
openedKey = Registry::CurrentUser->OpenSubKey("RegistryRightsExample",
false);
openedKey->SetAccessControl(regSecurity);
Console::WriteLine("{0}Example key permissions were changed.",
Environment::NewLine);
}
catch (UnauthorizedAccessException^ ex)
{
Console::WriteLine("{0}You are not authorized to change " +
"permissions for the example key:{0}{1}", Environment::NewLine, ex);
}
if (openedKey != nullptr)
{
openedKey->Close();
}
Console::WriteLine("{0}Press Enter to delete the example key.",
Environment::NewLine);
Console::ReadLine();
try
{
Registry::CurrentUser->DeleteSubKey("RegistryRightsExample");
Console::WriteLine("Example key was deleted.");
}
catch(SecurityException^ ex)
{
Console::WriteLine("{0}You do not have the permissions required to "
+ "delete the example key:{0}{1}", Environment::NewLine, ex);
}
}
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.
Comentarios
Use la RegistryRights enumeración para especificar los derechos de acceso del Registro al crear RegistrySecurity objetos. Para aplicar derechos de acceso a una clave del Registro, primero agregue RegistryAccessRule objetos a un RegistrySecurity objeto y, a continuación, adjunte el RegistrySecurity objeto a la clave mediante el RegistryKey.SetAccessControl método o una sobrecarga adecuada del RegistryKey.CreateSubKey método .