internal static RegistryKey OpenKey( string key, RegistryKeyPermissionCheck permissionCheck )
{
var root = OpenRoot( key );
var path = key.Replace( root.Name, string.Empty ).Trim( '\\' );
if ( string.IsNullOrEmpty( path ) )
{
return root;
}
using ( root )
{
return root.CreateSubKey( path, permissionCheck );
}
}
/// <summary>
/// Function to create a new SubKey in the Windows Registry
/// </summary>
/// <param name="KeyPermissions">RegistryKepPermissionCheck -> Specifies permissions of the SubKey to be created</param>
/// <returns>True (Succeeded)/False (Failed)</returns>
/// <remarks>Created 22DEC07 -> Richard L. McCutchen</remarks>
public bool CreateRegistrySubKey(RegistryKeyPermissionCheck KeyPermissions)
{
try
{
MainKey.CreateSubKey(Key, KeyPermissions);
return true;
}
catch (Exception ex)
{
//since an exception occurred we need to let the user know
MessageBox.Show(ex.Message, "Error: Creating SubKey", MessageBoxButtons.OK, MessageBoxIcon.Error);
//set our success variable to false since it failed
return false;
}
//return the value to the calling method
return IsSuccessful;
}
private RegistryKey?InternalOpenSubKeyCore(string name, RegistryKeyPermissionCheck permissionCheck, int rights)
{
int ret = Interop.Advapi32.RegOpenKeyEx(_hkey, name, 0, (rights | (int)_regView), out SafeRegistryHandle result);
if (ret == 0 && !result.IsInvalid)
{
RegistryKey key = new RegistryKey(result, (permissionCheck == RegistryKeyPermissionCheck.ReadWriteSubTree), false, _remoteKey, false, _regView);
key._keyName = _keyName + "\\" + name;
key._checkMode = permissionCheck;
return(key);
}
if (ret == Interop.Errors.ERROR_ACCESS_DENIED || ret == Interop.Errors.ERROR_BAD_IMPERSONATION_LEVEL)
{
// We need to throw SecurityException here for compatibility reason,
// although UnauthorizedAccessException will make more sense.
throw new SecurityException(SR.Security_RegistryPermission);
}
// Return null if we didn't find the key.
return(null);
}
public RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions)
{
ValidateKeyOptions(registryOptions);
ValidateKeyName(subkey);
ValidateKeyMode(permissionCheck);
EnsureWriteable();
subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
// only keys opened under read mode is not writable
if (!_remoteKey)
{
RegistryKey?key = InternalOpenSubKeyWithoutSecurityChecks(subkey, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree));
if (key != null)
{
// Key already exits
key._checkMode = permissionCheck;
return(key);
}
}
return(CreateSubKeyInternalCore(subkey, permissionCheck, registryOptions));
}
private static int GetRegistryKeyAccess(RegistryKeyPermissionCheck mode)
{
int winAccess = 0;
switch (mode)
{
case RegistryKeyPermissionCheck.ReadSubTree:
case RegistryKeyPermissionCheck.Default:
winAccess = Interop.Advapi32.RegistryOperations.KEY_READ;
break;
case RegistryKeyPermissionCheck.ReadWriteSubTree:
winAccess = Interop.Advapi32.RegistryOperations.KEY_READ | Interop.Advapi32.RegistryOperations.KEY_WRITE;
break;
default:
Debug.Fail("unexpected code path");
break;
}
return(winAccess);
}
public static RegistryKey OpenRegistryKey(string name, RegistryKeyPermissionCheck registryKeyPermissionCheck, RegistryRights registryRights)
{
ThrowIfNullEmptyOrWhiteSpace(name, nameof(name));
string originalName = name;
string registryKeyName;
if (name.Contains(WinCopies.IO.Path.PathSeparator, out int result))
{
registryKeyName = name.Substring(0, result);
name = name.Length == 1 ? "" : name.Substring(result + 1);
}
else
{
registryKeyName = name;
name = "";
}
FieldInfo[] fields = typeof(Microsoft.Win32.Registry).GetFields();
var registryKeys = new KeyValuePair <RegistryKey, string> [fields.Length];
RegistryKey item;
for (int i = 0; i < fields.Length; i++)
{
item = (RegistryKey)fields[i].GetValue(null);
registryKeys[i] = new KeyValuePair <RegistryKey, string>(item, item.Name);
}
if (If(ComparisonType.Or, ComparisonMode.Logical, Comparison.Equal, out RegistryKey registryKey, registryKeyName, registryKeys))
{
return(name.Length > 0 ? registryKey.OpenSubKey(name, registryKeyPermissionCheck, registryRights) : registryKey);
}
private unsafe RegistryKey CreateSubKeyInternalCore(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions)
{
Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = default;
// By default, the new key will be writable.
int ret = Interop.Advapi32.RegCreateKeyEx(_hkey,
subkey,
0,
null,
(int)registryOptions /* specifies if the key is volatile */,
GetRegistryKeyAccess(permissionCheck != RegistryKeyPermissionCheck.ReadSubTree) | (int)_regView,
ref secAttrs,
out SafeRegistryHandle result,
out int _);
if (ret == 0 && !result.IsInvalid)
{
RegistryKey key = new RegistryKey(result, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree), false, _remoteKey, false, _regView);
key._checkMode = permissionCheck;
if (subkey.Length == 0)
{
key._keyName = _keyName;
}
else
{
key._keyName = _keyName + "\\" + subkey;
}
return(key);
}
else if (ret != 0) // syscall failed, ret is an error code.
{
Win32Error(ret, _keyName + "\\" + subkey); // Access denied?
}
Debug.Fail("Unexpected code path in RegistryKey::CreateSubKey");
return(null);
}
static RegistryKey SwallowRegKey(RegistryKey root, string key, RegistryKeyPermissionCheck newPermission)
{
string userName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
//MessageBox.Show("swallow1");
RegistryKey rk = root.OpenSubKey(key, RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryRights.ChangePermissions | RegistryRights.ReadKey);//Get the registry key desired with ChangePermissions Rights.
if (rk == null)
{
return(null);
}
RegistrySecurity rs = new RegistrySecurity();
rs.AddAccessRule(new RegistryAccessRule(userName, RegistryRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AccessControlType.Allow)); //Create access rule giving full control to the Administrator user.
rk.SetAccessControl(rs); //Apply the new access rule to this Registry Key.
rk.Close();
//rk = root.OpenSubKey(key, RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryRights.FullControl); // Opens the key again with full control.
//rs.SetOwner(new NTAccount(userName));// Set the securitys owner to be Administrator
//rk.SetAccessControl(rs);// Set the key with the changed permission so Administrator is now owner.
//rk.Close();
rk = root.OpenSubKey(key, newPermission, RegistryRights.FullControl);
//MessageBox.Show("swallow2");
return(rk);
}
private static bool TryGetCategoryKey(out RegistryKey registryKey)
{
const string keyName =
PsConstants.DefaultRegistryRoot + @"\\FontAndColors\\{358463D0-D084-400F-997E-A34FC570BC72}";
try
{
const RegistryKeyPermissionCheck keyPermissionCheck = RegistryKeyPermissionCheck.ReadSubTree;
const RegistryRights registryRights = RegistryRights.QueryValues | RegistryRights.ReadKey;
registryKey = Registry.CurrentUser.OpenSubKey(keyName, keyPermissionCheck, registryRights);
if (registryKey != null)
{
return(true);
}
registryKey = Registry.LocalMachine.OpenSubKey(keyName, keyPermissionCheck, registryRights);
return(registryKey != null);
}
catch (SecurityException)
{
// nothing I can do
registryKey = null;
return(false);
}
}
public static bool Emulate(uint version)
{
string name = new FileInfo(Application.ExecutablePath).Name;
RegistryKeyPermissionCheck readwrite = RegistryKeyPermissionCheck.ReadWriteSubTree;
//RegistryKey key = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION", true);
RegistryKey key = Registry.CurrentUser.CreateSubKey("Software", readwrite).CreateSubKey("Microsoft", readwrite).CreateSubKey("Internet Explorer", readwrite)
.CreateSubKey("Main", readwrite).CreateSubKey("FeatureControl", readwrite).CreateSubKey("FEATURE_BROWSER_EMULATION", readwrite);
if (!key.GetValueNames().Contains(name))
{
key.SetValue(name, version, RegistryValueKind.DWord);
return(false);
}
else
{
uint currVal = Convert.ToUInt32(key.GetValue(name));
if (currVal == version)
{
return(true);
}
key.SetValue(name, version, RegistryValueKind.DWord);
return(false);
}
}
public RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck, System.Security.AccessControl.RegistryRights rights)
{
return default(RegistryKey);
}
public RegistryKey OpenSubKey (string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
throw new NotImplementedException ();
}
public RegistryKey OpenSubKey (string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
return OpenSubKey (name, permissionCheck == RegistryKeyPermissionCheck.ReadWriteSubTree);
}
public RegistryKey CreateSubKey (string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions options)
{
AssertKeyStillValid ();
AssertKeyNameNotNull (subkey);
AssertKeyNameLength (subkey);
if (!IsWritable)
throw new UnauthorizedAccessException ("Cannot write to the registry key.");
return RegistryApi.CreateSubKey (this, subkey, options);
}
private unsafe TransactedRegistryKey CreateSubKeyInternal(String subkey, RegistryKeyPermissionCheck permissionCheck, object registrySecurityObj)
{
ValidateKeyName(subkey);
// RegCreateKeyTransacted requires a non-empty key name, so let's deal with that here.
if (string.Empty == subkey)
{
throw new ArgumentException(RegistryProviderStrings.Arg_RegKeyStrEmpty);
}
ValidateKeyMode(permissionCheck);
EnsureWriteable();
subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
// only keys opened under read mode is not writable
TransactedRegistryKey existingKey = InternalOpenSubKey(subkey, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree));
if (existingKey != null)
{ // Key already exits
CheckSubKeyWritePermission(subkey);
CheckSubTreePermission(subkey, permissionCheck);
existingKey._checkMode = permissionCheck;
return existingKey;
}
CheckSubKeyCreatePermission(subkey);
Win32Native.SECURITY_ATTRIBUTES secAttrs = null;
TransactedRegistrySecurity registrySecurity = registrySecurityObj as TransactedRegistrySecurity;
// For ACL's, get the security descriptor from the RegistrySecurity.
if (registrySecurity != null)
{
secAttrs = new Win32Native.SECURITY_ATTRIBUTES();
secAttrs.nLength = (int)Marshal.SizeOf(secAttrs);
byte[] sd = registrySecurity.GetSecurityDescriptorBinaryForm();
// We allocate memory on the stack to improve the speed.
// So this part of code can't be refactored into a method.
byte* pSecDescriptor = stackalloc byte[sd.Length];
Microsoft.PowerShell.Commands.Internal.Buffer.memcpy(sd, 0, pSecDescriptor, 0, sd.Length);
secAttrs.pSecurityDescriptor = pSecDescriptor;
}
int disposition = 0;
// By default, the new key will be writable.
SafeRegistryHandle result = null;
int ret = 0;
SafeTransactionHandle safeTransactionHandle = GetTransactionHandle();
ret = Win32Native.RegCreateKeyTransacted(_hkey,
subkey,
0,
null,
0,
GetRegistryKeyAccess(permissionCheck != RegistryKeyPermissionCheck.ReadSubTree),
secAttrs,
out result,
out disposition,
safeTransactionHandle,
IntPtr.Zero
);
if (ret == 0 && !result.IsInvalid)
{
TransactedRegistryKey key = new TransactedRegistryKey(result, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree), false,
Transaction.Current, safeTransactionHandle);
CheckSubTreePermission(subkey, permissionCheck);
key._checkMode = permissionCheck;
if (subkey.Length == 0)
key._keyName = _keyName;
else
key._keyName = _keyName + "\\" + subkey;
return key;
}
else if (ret != 0) // syscall failed, ret is an error code.
Win32Error(ret, _keyName + "\\" + subkey); // Access denied?
BCLDebug.Assert(false, "Unexpected code path in RegistryKey::CreateSubKey");
return null;
}
private static int GetRegistryKeyAccess(RegistryKeyPermissionCheck mode)
{
int winAccess = 0;
switch (mode)
{
case RegistryKeyPermissionCheck.ReadSubTree:
case RegistryKeyPermissionCheck.Default:
winAccess = Win32Native.KEY_READ;
break;
case RegistryKeyPermissionCheck.ReadWriteSubTree:
winAccess = Win32Native.KEY_READ | Win32Native.KEY_WRITE;
break;
default:
BCLDebug.Assert(false, "unexpected code path");
break;
}
return winAccess;
}
public static RegistryKey OpenKeyImpl(string baseKeyPath, string suffix, bool localMachine, RegistryKeyPermissionCheck permissions)
{
// Add the suffix
string keyPath;
if (string.IsNullOrEmpty(suffix))
{
keyPath = baseKeyPath;
}
else
{
keyPath = CombineKeys(baseKeyPath, suffix);
}
// Open the key.
using (RegistryKey hive = RegistryKey.OpenBaseKey(localMachine ? RegistryHive.LocalMachine : RegistryHive.CurrentUser, RegistryView.Registry64))
{
RegistryKey key = hive.OpenSubKey(keyPath, permissions);
if (key == null)
{
// Try creating it if writeable
if (permissions == RegistryKeyPermissionCheck.ReadWriteSubTree)
{
key = hive.CreateSubKey(keyPath, permissions);
}
}
return(key);
}
}
public static extern IntPtr SetupDiOpenDevRegKey(IntPtr hDeviceInfoSet, ref SP_DEVINFO_DATA deviceInfoData, int scope, int hwProfile, DevKeyType keyType, RegistryKeyPermissionCheck samDesired);
/// <inheritdoc />
public IRegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck)
{
return(OpenSubKey(name, permissionCheck, RegistryRights.FullControl));
}
/// <inheritdoc />
public IRegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck)
{
return(CreateSubKey(subkey, permissionCheck, new RegistrySecurity()));
}
public RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck)
{
ValidateKeyMode(permissionCheck);
return(OpenSubKey(name, permissionCheck, (RegistryRights)GetRegistryKeyAccess(permissionCheck)));
}
public RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistrySecurity registrySecurity)
{
return(CreateSubKey(subkey, permissionCheck, RegistryOptions.None));
}
public RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
return(OpenSubKey(name, permissionCheck == RegistryKeyPermissionCheck.ReadWriteSubTree));
}
public RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck)
{
return default(RegistryKey);
}
public RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck)
{
return(CreateSubKey(subkey));
}
private static int GetRegistryKeyAccess(RegistryKeyPermissionCheck mode)
{
throw new PlatformNotSupportedException(SR.PlatformNotSupported_Registry);
}
public TransactedRegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck)
{
return CreateSubKeyInternal(subkey, permissionCheck, (TransactedRegistrySecurity)null);
}
private RegistryKey CreateSubKeyInternalCore(string subkey, RegistryKeyPermissionCheck permissionCheck, object registrySecurityObj, RegistryOptions registryOptions)
{
throw new PlatformNotSupportedException(SR.PlatformNotSupported_Registry);
}
public TransactedRegistryKey OpenSubKey(String name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
return InternalOpenSubKey(name, permissionCheck, (int)rights);
}
private RegistryKey InternalOpenSubKeyCore(string name, RegistryKeyPermissionCheck permissionCheck, int rights, bool throwOnPermissionFailure)
{
throw new PlatformNotSupportedException(SR.PlatformNotSupported_Registry);
}
public RegistryKey OpenSubKey (string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
return OpenSubKey (name);
}
public static RegistryKey GetRegistryKey(string regPath, RegistryKeyPermissionCheck check, RegistryRights rights)
{
GetRootAndSubRegPath(regPath, out RegistryKey root, out string keyPath);
using (root) return(root.OpenSubKey(keyPath, check, rights));
}
public RegistryKey CreateSubKey (string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions,
RegistrySecurity registrySecurity)
{
return CreateSubKey (subkey, permissionCheck, registryOptions);
}
/// <inheritdoc />
public IRegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistrySecurity registrySecurity)
{
return(new WindowsRegistryKey(_registryKey.CreateSubKey(subkey, permissionCheck, registrySecurity)));
}
public RegistryKey CreateSubKey (string subkey, RegistryKeyPermissionCheck permissionCheck, RegistrySecurity registrySecurity)
{
throw new NotImplementedException ();
}
protected RegistryKeyBase(RegistryKeyPermissionCheck permissionCheck)
{
CheckMode = permissionCheck;
}
public RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck)
{
return default(RegistryKey);
}
public virtual RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistrySecurity registrySecurity)
{
return(this.CreateSubKey(subkey, permissionCheck, RegistryOptions.None, registrySecurity));
}
public RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions, System.Security.AccessControl.RegistrySecurity registrySecurity)
{
return default(RegistryKey);
}
public virtual RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck)
{
return(this.OpenSubKey(name, permissionCheck, GetRegistryKeyAccess(permissionCheck)));
}
/// <inheritdoc />
public IRegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights)
{
var subkey = _registryKey.OpenSubKey(name, permissionCheck, rights);
return(subkey != null ? new WindowsRegistryKey(subkey) : null);
}
private void CheckOpenSubKeyPermission(string subkeyName, RegistryKeyPermissionCheck subKeyCheck)
{
if (subKeyCheck == RegistryKeyPermissionCheck.Default)
{
if (_checkMode == RegistryKeyPermissionCheck.Default)
{
CheckSubKeyReadPermission(subkeyName);
}
}
CheckSubTreePermission(subkeyName, subKeyCheck);
}
public abstract RegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck, RegistryRights rights);
private void CheckPermission(RegistryInternalCheck check, string item, bool subKeyWritable, RegistryKeyPermissionCheck subKeyCheck)
{
// TODO: Cleanup
}
public virtual RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions options)
{
return(this.CreateSubKey(subkey, permissionCheck, options, null));
}
static private void ValidateKeyMode(RegistryKeyPermissionCheck mode) {
if( mode < RegistryKeyPermissionCheck.Default || mode > RegistryKeyPermissionCheck.ReadWriteSubTree) {
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck, ExceptionArgument.mode);
}
}
public abstract RegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions, RegistrySecurity registrySecurity);
public RegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions options)
{
return CreateSubKeyInternal(subkey, permissionCheck, null, options);
}
protected virtual RegistryKey _RegistryLocalMachineCreateSubKey(string key, RegistryKeyPermissionCheck permissionCheck)
{
return(Registry.LocalMachine.CreateSubKey(key, permissionCheck));
}
public unsafe RegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck, RegistryOptions registryOptions, RegistrySecurity registrySecurity)
{
return CreateSubKeyInternal(subkey, permissionCheck, registrySecurity, registryOptions);
}
private void CheckSubTreePermission(string subkeyName, RegistryKeyPermissionCheck subKeyCheck)
{
if (subKeyCheck == RegistryKeyPermissionCheck.ReadSubTree)
{
if (_checkMode == RegistryKeyPermissionCheck.Default)
{
CheckSubTreeReadPermission(subkeyName);
}
}
else if (subKeyCheck == RegistryKeyPermissionCheck.ReadWriteSubTree)
{
if (_checkMode != RegistryKeyPermissionCheck.ReadWriteSubTree)
{
CheckSubTreeReadWritePermission(subkeyName);
}
}
}
private unsafe RegistryKey CreateSubKeyInternal(String subkey, RegistryKeyPermissionCheck permissionCheck, object registrySecurityObj, RegistryOptions registryOptions)
{
ValidateKeyOptions(registryOptions);
ValidateKeyName(subkey);
ValidateKeyMode(permissionCheck);
EnsureWriteable();
subkey = FixupName(subkey); // Fixup multiple slashes to a single slash
// only keys opened under read mode is not writable
if (!remoteKey) {
RegistryKey key = InternalOpenSubKey(subkey, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree));
if (key != null) { // Key already exits
CheckPermission(RegistryInternalCheck.CheckSubKeyWritePermission, subkey, false, RegistryKeyPermissionCheck.Default);
CheckPermission(RegistryInternalCheck.CheckSubTreePermission, subkey, false, permissionCheck);
key.checkMode = permissionCheck;
return key;
}
}
CheckPermission(RegistryInternalCheck.CheckSubKeyCreatePermission, subkey, false, RegistryKeyPermissionCheck.Default);
Win32Native.SECURITY_ATTRIBUTES secAttrs = null;
#if FEATURE_MACL
RegistrySecurity registrySecurity = (RegistrySecurity)registrySecurityObj;
// For ACL's, get the security descriptor from the RegistrySecurity.
if (registrySecurity != null) {
secAttrs = new Win32Native.SECURITY_ATTRIBUTES();
secAttrs.nLength = (int)Marshal.SizeOf(secAttrs);
byte[] sd = registrySecurity.GetSecurityDescriptorBinaryForm();
// We allocate memory on the stack to improve the speed.
// So this part of code can't be refactored into a method.
byte* pSecDescriptor = stackalloc byte[sd.Length];
Buffer.Memcpy(pSecDescriptor, 0, sd, 0, sd.Length);
secAttrs.pSecurityDescriptor = pSecDescriptor;
}
#endif
int disposition = 0;
// By default, the new key will be writable.
SafeRegistryHandle result = null;
int ret = Win32Native.RegCreateKeyEx(hkey,
subkey,
0,
null,
(int)registryOptions /* specifies if the key is volatile */,
GetRegistryKeyAccess(permissionCheck != RegistryKeyPermissionCheck.ReadSubTree) | (int)regView,
secAttrs,
out result,
out disposition);
if (ret == 0 && !result.IsInvalid) {
RegistryKey key = new RegistryKey(result, (permissionCheck != RegistryKeyPermissionCheck.ReadSubTree), false, remoteKey, false, regView);
CheckPermission(RegistryInternalCheck.CheckSubTreePermission, subkey, false, permissionCheck);
key.checkMode = permissionCheck;
if (subkey.Length == 0)
key.keyName = keyName;
else
key.keyName = keyName + "\\" + subkey;
return key;
}
else if (ret != 0) // syscall failed, ret is an error code.
Win32Error(ret, keyName + "\\" + subkey); // Access denied?
BCLDebug.Assert(false, "Unexpected code path in RegistryKey::CreateSubKey");
return null;
}
private static void ValidateKeyMode(RegistryKeyPermissionCheck mode)
{
if (mode < RegistryKeyPermissionCheck.Default || mode > RegistryKeyPermissionCheck.ReadWriteSubTree)
{
throw new ArgumentException(RegistryProviderStrings.Argument_InvalidRegistryKeyPermissionCheck);
}
}
[System.Security.SecurityCritical] // auto-generated
private RegistryKey InternalOpenSubKey(String name, RegistryKeyPermissionCheck permissionCheck, int rights) {
ValidateKeyName(name);
ValidateKeyMode(permissionCheck);
ValidateKeyRights(rights);
EnsureNotDisposed();
name = FixupName(name); // Fixup multiple slashes to a single slash
CheckPermission(RegistryInternalCheck.CheckOpenSubKeyPermission, name, false, permissionCheck);
CheckPermission(RegistryInternalCheck.CheckSubTreePermission, name, false, permissionCheck);
SafeRegistryHandle result = null;
int ret = Win32Native.RegOpenKeyEx(hkey, name, 0, (rights | (int)regView), out result);
if (ret == 0 && !result.IsInvalid) {
RegistryKey key = new RegistryKey(result, (permissionCheck == RegistryKeyPermissionCheck.ReadWriteSubTree), false, remoteKey, false, regView);
key.keyName = keyName + "\\" + name;
key.checkMode = permissionCheck;
return key;
}
// Return null if we didn't find the key.
if (ret == Win32Native.ERROR_ACCESS_DENIED || ret == Win32Native.ERROR_BAD_IMPERSONATION_LEVEL) {
// We need to throw SecurityException here for compatiblity reason,
// although UnauthorizedAccessException will make more sense.
ThrowHelper.ThrowSecurityException(ExceptionResource.Security_RegistryPermission);
}
return null;
}
public unsafe TransactedRegistryKey CreateSubKey(String subkey, RegistryKeyPermissionCheck permissionCheck, TransactedRegistrySecurity registrySecurity)
{
return CreateSubKeyInternal(subkey, permissionCheck, registrySecurity);
}
internal static RegistryKey CloneKey( RegistryKey source, RegistryKeyPermissionCheck permissionCheck )
{
RegistryKey clone = OpenKey( source.Name, permissionCheck );
return clone;
}
public TransactedRegistryKey OpenSubKey(String name, RegistryKeyPermissionCheck permissionCheck)
{
ValidateKeyMode(permissionCheck);
return InternalOpenSubKey(name, permissionCheck, GetRegistryKeyAccess(permissionCheck));
}
private RegistryKey GetKey( string sectionName, RegistryKeyPermissionCheck permissionCheck )
{
RegistryKey key;
if ( Root.Name.EndsWith( ( sectionName ) ) )
{
key = CloneKey( Root, permissionCheck );
}
else
{
string trimmed = sectionName.Replace( Root.Name, string.Empty ).Trim( '\\' );
key = Root.CreateSubKey( trimmed, permissionCheck );
}
return key;
}
private TransactedRegistryKey InternalOpenSubKey(String name, RegistryKeyPermissionCheck permissionCheck, int rights)
{
ValidateKeyName(name);
ValidateKeyMode(permissionCheck);
ValidateKeyRights(rights);
EnsureNotDisposed();
name = FixupName(name); // Fixup multiple slashes to a single slash
CheckOpenSubKeyPermission(name, permissionCheck);
SafeRegistryHandle result = null;
int ret = 0;
SafeTransactionHandle safeTransactionHandle = GetTransactionHandle();
ret = RegOpenKeyTransactedWrapper(_hkey, name, 0, rights, out result, safeTransactionHandle, IntPtr.Zero);
if (ret == 0 && !result.IsInvalid)
{
TransactedRegistryKey key = new TransactedRegistryKey(result, (permissionCheck == RegistryKeyPermissionCheck.ReadWriteSubTree), false,
Transaction.Current, safeTransactionHandle);
key._keyName = _keyName + "\\" + name;
key._checkMode = permissionCheck;
return key;
}
// Return null if we didn't find the key.
if (ret == Win32Native.ERROR_ACCESS_DENIED || ret == Win32Native.ERROR_BAD_IMPERSONATION_LEVEL)
{
// We need to throw SecurityException here for compatibility reason,
// although UnauthorizedAccessException will make more sense.
throw new SecurityException(RegistryProviderStrings.Security_RegistryPermission);
}
return null;
}
private RegistryKey GetKey( string subKey, ref string sectionName, RegistryKeyPermissionCheck permissionCheck )
{
RegistryKey key;
if ( string.Equals( subKey, Root.Name ) )
{
sectionName = Root.Name.Substring( Root.Name.LastIndexOf( '\\' ) + 1 );
key = CloneKey( Root, permissionCheck );
}
else
{
key = Root.OpenSubKey( sectionName, permissionCheck );
}
return key;
}
