public void SaveValueRemote(string key, string name, string value)
{
Microsoft.Win32.RegistryValueKind regValueKind = GetValueKind(name);
RegistryKey regKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, this._remoteName).OpenSubKey(key, true);
regKey.SetValue(name, value, regValueKind);
}
private static bool RegisterModem(IntPtr hDeviceInfoSet, ref Win32Wrapper.SP_DEVINFO_DATA devInfoElem, string PortName, ref Win32Wrapper.SP_DRVINFO_DATA drvData)
{
if (!Win32Wrapper.SetupDiRegisterDeviceInfo(hDeviceInfoSet, ref devInfoElem, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
return(false);
}
IntPtr hKeyDev = Win32Wrapper.SetupDiOpenDevRegKey(hDeviceInfoSet, ref devInfoElem, (uint)Win32Wrapper.DICS_FLAG.DICS_FLAG_GLOBAL, 0, (uint)Win32Wrapper.DIREG.DIREG_DEV, (uint)Win32Wrapper.REGKEYSECURITY.KEY_READ);
if (hKeyDev.ToInt64() == INVALID_HANDLE_VALUE && Marshal.GetLastWin32Error() == (int)Win32Wrapper.WinErrors.ERROR_KEY_DOES_NOT_EXIST)
{
hKeyDev = Win32Wrapper.SetupDiCreateDevRegKey(hDeviceInfoSet, ref devInfoElem, (int)Win32Wrapper.DICS_FLAG.DICS_FLAG_GLOBAL, 0, (int)Win32Wrapper.DIREG.DIREG_DRV, IntPtr.Zero, IntPtr.Zero);
if (hKeyDev.ToInt64() == INVALID_HANDLE_VALUE)
{
return(false);
}
}
bool check = Win32Wrapper.SetupDiRegisterDeviceInfo(hDeviceInfoSet, ref devInfoElem, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!Win32Wrapper.SetupDiGetSelectedDriver(hDeviceInfoSet, ref devInfoElem, ref drvData))
{
int err = Marshal.GetLastWin32Error();
Console.WriteLine("No driver selected");
}
Microsoft.Win32.RegistryValueKind RegType = Microsoft.Win32.RegistryValueKind.String;
int size = (PortName.Length + 1) * Marshal.SystemDefaultCharSize;
int ret = Win32Wrapper.RegSetValueEx(hKeyDev, "AttachedTo", 0, (uint)RegType, PortName, (uint)size);
Win32Wrapper.RegCloseKey(hKeyDev);
return(true);
}
static extern int RegSetValueEx(
IntPtr hKey,
[MarshalAs(UnmanagedType.LPStr)] string lpValueName,
int Reserved,
Microsoft.Win32.RegistryValueKind dwType,
[MarshalAs(UnmanagedType.LPStr)] string lpData,
int cbData);
static extern Int32 RegSetValueEx(
UInt32 hKey,
[MarshalAs(UnmanagedType.LPStr)] String lpValueName,
Int32 Reserved,
Microsoft.Win32.RegistryValueKind dwType,
IntPtr lpData,
Int32 cbData);
public static extern int CM_Get_DevNode_Registry_Property(
uint deviceInstance,
uint property,
out Microsoft.Win32.RegistryValueKind pulRegDataType,
IntPtr buffer,
ref uint length,
uint flags);
/// <summary>
/// Sets or deletes the desired registry value using the designated registry value kind.
/// Will create the specified subkey if it does not exist.
/// </summary>
/// <remarks>
/// This will use the following value types:
/// int => DWORD
/// byte[] => Binary
/// string[] => MultiString
/// other array => FAILS
/// other => String
/// </remarks>
/// <param name="hive">The root key to use.</param>
/// <param name="subkeyName">Subkey name or subpath.</param>
/// <param name="valueName">Name of value</param>
/// <param name="value">The value to set or null to delete the existing value, if any.</param>
/// <param name="valueKind">Kind of registry value</param>
/// <returns>'true' if successful.</returns>
public static bool SetRegistryValue <T>(RegistryHive hive, string subkeyName, string valueName, T value)
{
// Causes the behavior detailed in the remarks above
Win32.RegistryValueKind valueKind = Win32.RegistryValueKind.Unknown;
Win32.RegistryKey registryKey = GetHive(hive);
var registrySubkey = OpenSubkey(registryKey, subkeyName, writable: true);
if (registrySubkey == null)
{
// Key not found, now create it
if (value == null)
{
// No point in creating a subkey for a value we're going to delete
return(true);
}
Exception exception = RegistryExceptionWrapper(() => registrySubkey = registryKey.CreateSubKey(subkeyName));
if (exception != null)
{
Debug.WriteLine("Unable to create sub key '{0}'. Exception follows: \n{1}", subkeyName, exception);
return(false);
}
}
if (registrySubkey != null)
{
try
{
Exception exception = null;
if (value == null)
{
// Value specified is null- delete
exception = RegistryExceptionWrapper(() => registrySubkey.DeleteValue(valueName, false));
}
else
{
// Normal set
exception = RegistryExceptionWrapper(() => registrySubkey.SetValue(valueName, value, valueKind));
}
if (exception != null)
{
Debug.WriteLine("Unable to set value '{0}'. Exception follows: \n{1}", valueName, exception);
return(false);
}
else
{
return(true);
}
}
finally
{
registrySubkey.Close();
}
}
return(false);
}
public void SaveValue(string key, string name, string value)
{
Microsoft.Win32.RegistryValueKind regValueKind = GetValueKind(name);
RegistryKey regKey = Registry.LocalMachine.OpenSubKey(key);
Registry.SetValue(regKey.ToString(), name, value, regValueKind);
}
/// <summary>
/// Installs all registry values packaged in the installer to the local device
/// </summary>
public void InstallRegValues()
{
m_failedRegVals = 0;
if (m_descriptor.RegistryKeys == null)
{
return;
}
foreach (InstallerRegistryKey key in m_descriptor.RegistryKeys)
{
string keyName = string.Format("{0}{1}", m_descriptor.GetHiveByHiveID(key.HiveID).ToString(), m_descriptor.GetSubkeyByHiveID(key.HiveID));
string valueName = string.Copy(key.ValueName);
Microsoft.Win32.RegistryValueKind valueKind = Microsoft.Win32.RegistryValueKind.Unknown;
switch (key.KeyType & (~RegistyKeyType.NoClobber))
{
case RegistyKeyType.Binary:
valueKind = Microsoft.Win32.RegistryValueKind.Binary;
break;
case RegistyKeyType.MultiString:
valueKind = Microsoft.Win32.RegistryValueKind.MultiString;
break;
case RegistyKeyType.Number:
valueKind = Microsoft.Win32.RegistryValueKind.DWord;
break;
case RegistyKeyType.String:
valueKind = Microsoft.Win32.RegistryValueKind.String;
break;
}
byte[] data = (byte[])key.Data.Clone();
RegistryInstallInfo registryInfo = new RegistryInstallInfo(((key.KeyType & RegistyKeyType.NoClobber) == RegistyKeyType.NoClobber), keyName, valueName, valueKind, data);
try
{
OnInstallRegValue(ref registryInfo);
}
catch (Exception ex)
{
if (RegistryFailure != null)
{
bool cancel = false;
RegistryFailure(registryInfo, ex, ref cancel);
if (!cancel)
{
m_failedRegVals++;
}
}
else
{
m_failedRegVals++;
}
}
}
}
public static extern uint RegQueryValueEx(
UIntPtr hKey,
String lpValueName,
Int32 lpReserved,
ref MW32.RegistryValueKind lpType,
IntPtr lpData,
ref Int32 lpcbData
);
public static extern uint RegQueryValueEx(
uint kHey,
string lpValueName,
int lpReserved,
ref Microsoft.Win32.RegistryValueKind lpType,
ref uint lpData,
ref uint lpcbData
);
/// <summary>
/// 在注册表里添加键值
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="valueKind"></param>
public void SetValue(string name, string value, Microsoft.Win32.RegistryValueKind valueKind)
{
try
{
softWare.SetValue(name, value, valueKind);
}
catch (Exception ex)
{
MessageBox.Show("出现异常：" + ex);
}
}
/// <summary>
/// Sets a value in the registry.
/// </summary>
/// <param name="RegHiveKeyValue">The path to the registry key to set, including: hive, subkey, and value name.</param>
/// <param name="Value">The value to write to the registry key.</param>
/// <param name="ValueKind">The kind of value to write to the registry key.</param>
/// <returns>True if succeeded, false otherwise.</returns>
public static bool SetRegistryKey(string RegHiveKeyValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String)
{
string[] pieces = RegHiveKeyValue.Split(Path.DirectorySeparatorChar);
if (!pieces.Any())
{
return(false);
}
string RegHiveKey = "";
for (int i = 1; i < pieces.Length - 1; i++)
{
RegHiveKey = pieces[i] + Path.DirectorySeparatorChar;
}
return(SetRegistryKey(ConvertToRegistryHive(pieces.First()), RegHiveKey.Trim(Path.DirectorySeparatorChar), pieces[pieces.Length - 1], Value, ValueKind));
}
static bool Registry_Write(string index, object val, Microsoft.Win32.RegistryValueKind valkind)
{
try
{
if (Registry.GetValue("HKEY_CURRENT_USER\\Software\\CBomb", "Infected", false) == null /* hacky way to do the thing*/)
{
Registry.CurrentUser.CreateSubKey("Software\\CBomb");
}
Registry.SetValue("HKEY_CURRENT_USER\\Software\\CBomb", index, val, valkind);
return(true);
} catch (Exception)
{
return(false);
}
}
//TODO: Refactor, Move to a More be-fitting Class
internal void SetRegValueHKLM(string regkeyfolder, string paramname, string paramvalue,
Microsoft.Win32.RegistryValueKind keytype)
{
try
{
RegistryKey myKey = Registry.LocalMachine.OpenSubKey(regkeyfolder, true);
if (myKey != null)
{
myKey.SetValue(paramname, paramvalue, keytype);
myKey.Close();
}
}
catch (Exception ex)
{
// fatalerrors++;
logger.output(logger.GetTranslateText("Error") + ": " + ex.Message);
}
}
private void SetRegValueHKCU(string regkeyfolder, string paramname, string paramvalue,
Microsoft.Win32.RegistryValueKind keytype)
{
try
{
RegistryKey myKey = Registry.CurrentUser.OpenSubKey(regkeyfolder, true);
if (myKey != null)
{
myKey.SetValue(paramname, paramvalue, keytype);
myKey.Close();
}
}
catch (Exception ex)
{
fatalerrors++;
output(GetTranslateText("Error") + ": " + ex.Message);
}
}
/// <summary>
/// Set registry value, creating the key if neccesary. With support for 32 and 64 bit registries
/// </summary>
/// <param name="keyAndValue">Key name in format [\\machineName]RootKey[:32|:64]\subkey\value</param>
/// <param name="value">Value to set</param>
/// <param name="kind">Registry value kind</param>
/// <returns>previous value, or null if didn't exist</returns>
public static object RegistrySet(string keyAndValue, object value, Microsoft.Win32.RegistryValueKind kind)
{
if (keyAndValue == null)
{
throw new ArgumentNullException("keyAndValue");
}
object ret = RegistryGet(keyAndValue, null);
using (RegW64Helper rn = new RegW64Helper(keyAndValue))
{
using (var rk = rn.Create(RegistryKeyPermissionCheck.Default))
{
if (value == null)
{
rk.DeleteValue(rn.ValueName, false);
}
else
{
rk.SetValue(rn.ValueName, value, kind);
}
}
}
return(ret);
}
public static bool CheckRegistryValueExist(eRegistryRoot rootType, string keyPath, string paramterName,
object expectedValue, Microsoft.Win32.RegistryValueKind expectedValueType,
bool addValueIfMissing, bool silentMode)
{
bool addValue = false;
try
{
if ((GetRegistryValue(rootType, keyPath, paramterName) != null) &&
GetRegistryValue(rootType, keyPath, paramterName).ToString() == expectedValue.ToString())
{
return(true);
}
else
{
if (addValueIfMissing)
{
if (silentMode)
{
addValue = true;
}
else
{
//ask user
if ((Reporter.ToUser(eUserMsgKey.AddRegistryValue, rootType + "\\" + keyPath)) == eUserMsgSelection.Yes)
{
addValue = true;
}
else
{
return(false);
}
}
}
else
{
return(false);
}
if (addValue)
{
//create the registry key if needed
if (CreateRegistryKey(rootType, keyPath))
{
//add the registry value
if (SetRegistryValue(rootType, keyPath, paramterName, expectedValue, expectedValueType))
{
//succeed to add the value
if (!silentMode)
{
//show success to user
Reporter.ToUser(eUserMsgKey.AddRegistryValueSucceed, rootType + "\\" + keyPath);
}
return(true);
}
else
{
//failed to add the value
if (!silentMode)
{
//show failure to user
Reporter.ToUser(eUserMsgKey.AddRegistryValueFailed, rootType + "\\" + keyPath);
}
return(false);
}
}
else
{
if (!silentMode)
{
//show failure to user
Reporter.ToUser(eUserMsgKey.AddRegistryValueFailed, rootType + "\\" + keyPath);
}
return(false);
}
}
}
return(false);
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Failed to complete the registry value check for the key: " +
rootType + "\\" + keyPath, ex);
if (!silentMode)
{
Reporter.ToUser(eUserMsgKey.RegistryValuesCheckFailed);
}
return(false);
}
}
internal RegistryValue(string name, Microsoft.Win32.RegistryValueKind type, string value)
{
ValueName = name;
Type = type;
Value = value;
}
/// <summary>
/// Sets a value in the registry.
/// </summary>
/// <param name="RegHiveKey">The RegistryKey to set.</param>
/// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param>
/// <param name="Value">The value to write to the registry key.</param>
/// <param name="ValueKind">The kind of value to write to the registry key.</param>
/// <returns>True if succeeded, false otherwise.</returns>
private static bool SetRegistryKeyValue(Win.RegistryKey RegHiveKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String)
{
try
{
RegHiveKey.SetValue(RegValue, Value, ValueKind);
return(true);
}
catch (Exception e)
{
Console.Error.WriteLine(e.GetType().FullName + ": " + e.Message);
return(false);
}
}
/// <summary>
/// Sets a value in the registry.
/// </summary>
/// <param name="Hostname">Remote hostname to connect to for remote registry.</param>
/// <param name="RegHive">The RegistryHive to set within.</param>
/// <param name="RegKey">The RegistryKey to set, including the hive.</param>
/// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param>
/// <param name="Value">The value to write to the registry key.</param>
/// <param name="ValueKind">The kind of value to write to the registry key.</param>
/// <returns>True if succeeded, false otherwise.</returns>
public static bool SetRemoteRegistryKey(string Hostname, string RegHive, string RegKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String)
{
return(SetRemoteRegistryKey(Hostname, ConvertToRegistryHive(RegHive), RegKey, RegValue, Value, ValueKind));
}
/// <summary>
/// Sets a value in the registry.
/// </summary>
/// <param name="Hostname">Remote hostname to connect to for remote registry.</param>
/// <param name="RegHive">The RegistryHive to set within.</param>
/// <param name="RegKey">The RegistryKey to set, including the hive.</param>
/// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param>
/// <param name="Value">The value to write to the registry key.</param>
/// <param name="ValueKind">The kind of value to write to the registry key.</param>
/// <returns>True if succeeded, false otherwise.</returns>
public static bool SetRemoteRegistryKey(string Hostname, Win.RegistryHive RegHive, string RegKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String)
{
Win.RegistryKey baseKey = null;
switch (RegHive)
{
case Win.RegistryHive.CurrentUser:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentUser, Hostname);
break;
case Win.RegistryHive.LocalMachine:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.LocalMachine, Hostname);
break;
case Win.RegistryHive.ClassesRoot:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.ClassesRoot, Hostname);
break;
case Win.RegistryHive.CurrentConfig:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentConfig, Hostname);
break;
case Win.RegistryHive.Users:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.Users, Hostname);
break;
default:
baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentUser, Hostname);
break;
}
string[] pieces = RegKey.Split(Path.DirectorySeparatorChar);
for (int i = 0; i < pieces.Length; i++)
{
string[] subkeynames = baseKey.GetSubKeyNames();
if (!subkeynames.Contains(pieces[i], StringComparer.OrdinalIgnoreCase))
{
baseKey = baseKey.CreateSubKey(pieces[i]);
}
else
{
baseKey = baseKey.OpenSubKey(pieces[i], true);
}
}
return(SetRegistryKeyValue(baseKey, RegValue, Value, ValueKind));
}
