public static extern Win32Result GetValue(
IntPtr hKey,
string lpSubKey,
string lpValue,
out RegValueType pdwType,
IntPtr pvData,
ref uint pcbData);
/// <summary>
/// Sets a value to the REG_MULTI_SZ type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="values">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, string[] values, RegValueType type = RegValueType.REG_MULTI_SZ)
{
foreach (string value in values)
{
if (string.IsNullOrEmpty(value))
{
throw new ArgumentException("No empty strings allowed");
}
}
// A null char for each string, plus a null char at the end
int bytes = 0;
foreach (string value in values)
{
bytes += OffregHelper.StringEncoding.GetByteCount(value) + OffregHelper.SingleCharBytes;
}
bytes += OffregHelper.SingleCharBytes;
byte[] data = new byte[bytes];
int position = 0;
for (int i = 0; i < values.Length; i++)
{
// Save and increment position
position += OffregHelper.StringEncoding.GetBytes(values[i], 0, values[i].Length, data, position) +
OffregHelper.SingleCharBytes;
}
SetValue(name, type, data);
}
private string GetRegKeyType(RegValueType regValueType)
{
string result = null;
switch (regValueType)
{
case RegValueType.REG_NONE: // If none (the default setting) is specified, Setup will create the key but not a value. In this case the ValueName and ValueData parameters are ignored.
result = "none";
break;
case RegValueType.REG_SZ: // If string is specified, Setup will create a string (REG_SZ) value.
result = "string";
break;
case RegValueType.REG_EXPAND_SZ:// If expandsz is specified, Setup will create an expand-string (REG_EXPAND_SZ) value.
result = "expandsz";
break;
case RegValueType.REG_MULTI_SZ: // If multisz is specified, Setup will create an multi-string (REG_MULTI_SZ) value.
result = "multisz";
break;
case RegValueType.REG_DWORD: // If dword is specified, Setup will create a 32-bit integer (REG_DWORD) value.
result = "dword";
break;
case RegValueType.REG_QWORD: // If qword is specified, Setup will create a 64-bit integer (REG_QWORD) value.
result = "qword";
break;
case RegValueType.REG_BINARY: // If binary is specified, Setup will create a binary (REG_BINARY) value.
result = "binary";
break;
}
if(String.IsNullOrEmpty(result))
return "string";
else
return result;
}
private static RegistryValueKind ConvertFromOffreg(RegValueType reg)
{
switch (reg)
{
case RegValueType.REG_NONE:
return(RegistryValueKind.None);
case RegValueType.REG_SZ:
return(RegistryValueKind.String);
case RegValueType.REG_EXPAND_SZ:
return(RegistryValueKind.ExpandString);
case RegValueType.REG_BINARY:
return(RegistryValueKind.Binary);
case RegValueType.REG_DWORD:
case RegValueType.REG_DWORD_BIG_ENDIAN:
return(RegistryValueKind.DWord);
case RegValueType.REG_MULTI_SZ:
return(RegistryValueKind.MultiString);
case RegValueType.REG_QWORD:
return(RegistryValueKind.QWord);
default:
return(RegistryValueKind.Unknown);
}
}
public IsleRegKey(ref List <BaseRegKey> allRegistryKeys, XmlNode keyNode)
{
mRegistryKeys = allRegistryKeys;
Id = TdValue(ref keyNode, 0);
int regRoot = int.Parse(TdValue(ref keyNode, 1));
if (regRoot == -1)
{
regRoot = 2; // HKLM
}
Root = (RegRoot)regRoot;
Path = TdValue(ref keyNode, 2);
Values = new List <RegValue>();
RegValueType rvType = RegValueType.REG_NONE;
string value = TdValue(ref keyNode, 4);
if (value.Contains("#x"))
{
rvType = RegValueType.REG_BINARY;
value = value.Substring(2).Trim();
}
if (value.IndexOf('#') > -1)
{
rvType = RegValueType.REG_DWORD;
value = value.Substring(1).Trim();
}
Values.Add(new RegValue(TdValue(ref keyNode, 3), rvType, value));
// Add registry key
mRegistryKeys.Add(this);
}
private static extern Win32Result GetValue64(
IntPtr hKey,
string lpSubKey,
string lpValue,
out RegValueType pdwType,
IntPtr pvData,
IntPtr pcbData);
private static void ExampleRecurse(OffregKey key)
{
ValueContainer[] values = key.EnumerateValues();
if (values.Length > 0)
{
Console.WriteLine("[" + key.FullName + "]");
foreach (ValueContainer value in values)
{
RegValueType type = value.Type;
object data = value.Data;
Console.WriteLine(value.Name + " (" + type + ")=" + data);
}
Console.WriteLine("");
}
SubKeyContainer[] subKeys = key.EnumerateSubKeys();
foreach (SubKeyContainer subKey in subKeys)
{
try
{
using (OffregKey sub = key.OpenSubKey(subKey.Name))
{
ExampleRecurse(sub);
}
}
catch (Win32Exception ex)
{
Console.WriteLine("<" + key.FullName + " -> " + subKey.Name + ": " + ex.Message + ">");
}
}
}
/// <summary>
/// Sets a value to the specified type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="type">The optional type for the value.</param>
/// <param name="data">The data for the value.</param>
private void SetValue(string name, RegValueType type, byte[] data)
{
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, dataPtr, data.Length);
Win32Result result = OffregNative.SetValue(_intPtr, name, type, dataPtr, (uint)data.Length);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
}
finally
{
if (dataPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(dataPtr);
}
}
RefreshMetadata();
}
/// <summary>
/// Sets a value to the REG_SZ type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, string value, RegValueType type = RegValueType.REG_SZ)
{
// Always leave a trailing null-terminator
byte[] data = new byte[OffregHelper.StringEncoding.GetByteCount(value) + OffregHelper.SingleCharBytes];
OffregHelper.StringEncoding.GetBytes(value, 0, value.Length, data, 0);
SetValue(name, type, data);
}
private static extern Win32Result EnumValue64(
IntPtr hKey,
uint dwIndex,
StringBuilder lpValueName,
ref uint lpcchValueName,
out RegValueType lpType,
IntPtr lpData,
ref uint lpcbData);
/// <summary>
/// Sets a value.
/// See http://msdn.microsoft.com/en-us/library/ee210775(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open key.</param>
/// <param name="lpValueName">The name of the value.</param>
/// <param name="dwType">The type of the value.</param>
/// <param name="lpData">The data buffer to save in the value.</param>
/// <param name="cbData">The size of the data buffer.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result SetValue(IntPtr hKey,
string lpValueName,
RegValueType dwType,
IntPtr lpData,
uint cbData)
{
return(Is64BitProcess
? SetValue64(hKey, lpValueName, dwType, lpData, cbData)
: SetValue32(hKey, lpValueName, dwType, lpData, cbData));
}
/// <summary>
/// Gets a value under a key.
/// See http://msdn.microsoft.com/en-us/library/ee210767(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open key.</param>
/// <param name="lpSubKey">The name of the subkey under the parent, from which to retrieve the value. May be null.</param>
/// <param name="lpValue">Name of the value to retrieve.</param>
/// <param name="pdwType">The type of the value.</param>
/// <param name="pvData">Unused - set to Intpr.Zero.</param>
/// <param name="pcbData">Unused - set to Intpr.Zero.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result GetValue(IntPtr hKey,
string lpSubKey,
string lpValue,
out RegValueType pdwType,
IntPtr pvData,
IntPtr pcbData)
{
return(Is64BitProcess
? GetValue64(hKey, lpSubKey, lpValue, out pdwType, pvData, pcbData)
: GetValue32(hKey, lpSubKey, lpValue, out pdwType, pvData, pcbData));
}
/// <summary>
/// Enumerate a keys values.
/// See http://msdn.microsoft.com/en-us/library/ee210765(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open parent key.</param>
/// <param name="dwIndex">Index of the child to retrieve.</param>
/// <param name="lpValueName">Buffer for the childs name.</param>
/// <param name="lpcchValueName">Size of the childs name buffer.</param>
/// <param name="lpType">Value type.</param>
/// <param name="lpData">Pointer to data buffer.</param>
/// <param name="lpcbData">Size of data buffer.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result EnumValue(IntPtr hKey,
uint dwIndex,
StringBuilder lpValueName,
ref uint lpcchValueName,
out RegValueType lpType,
IntPtr lpData,
ref uint lpcbData)
{
return(Is64BitProcess
? EnumValue64(hKey, dwIndex, lpValueName, ref lpcchValueName, out lpType, lpData, ref lpcbData)
: EnumValue32(hKey, dwIndex, lpValueName, ref lpcchValueName, out lpType, lpData, ref lpcbData));
}
/// <summary>
/// Sets a value to the REG_DWORD type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, int value, RegValueType type = RegValueType.REG_DWORD)
{
byte[] data = BitConverter.GetBytes(value);
if (type == RegValueType.REG_DWORD_BIG_ENDIAN)
{
// Reverse it
Array.Reverse(data);
}
SetValue(name, type, data);
}
public VdRegKey(ref List <BaseRegKey> allRegistryKeys, RegRoot root, string parentPath, XmlNode keyNode)
{
mRegistryKeys = allRegistryKeys;
Id = keyNode.Name;
Root = root;
if (String.IsNullOrEmpty(parentPath))
{
Path = ElementValue(ref keyNode, "Name");
}
else
{
Path += parentPath + "\\" + ElementValue(ref keyNode, "Name");
}
XmlNode regValues = keyNode.SelectSingleNode("Values");
// If there are no <Values then this is only parent of sub-key (so do not add it)
if (regValues != null && regValues.HasChildNodes)
{
Values = new List <RegValue>(regValues.ChildNodes.Count);
for (int k = 0; k < regValues.ChildNodes.Count; k++)
{
XmlNode valNode = regValues.ChildNodes[k];
string name = ElementValue(ref valNode, "Name");
RegValueType type = (RegValueType)int.Parse(ElementValue(ref valNode, "ValueTypes"));
string value = ElementValue(ref valNode, "Value");
Values.Add(new RegValue(name, type, value));
}
// Add registry key
mRegistryKeys.Add(this);
}
else
{
// Process sub-keys (without adding parent)
XmlNode subKeys = keyNode.SelectSingleNode("Keys");
if (subKeys != null && subKeys.HasChildNodes)
{
for (int i = 0; i < subKeys.ChildNodes.Count; i++)
{
XmlNode childNode = subKeys.ChildNodes[i];
VdRegKey regKey = new VdRegKey(ref mRegistryKeys, Root, Path, childNode);
}
}
else
{
// Add registry key (without Values)
mRegistryKeys.Add(this);
}
}
}
private void BinaryTest(RegValueType type, int size)
{
byte[] test = new byte[size];
new Random().NextBytes(test);
_key.SetValue("B", test, type);
Assert.AreEqual(type, _key.GetValueKind("B"));
object result = _key.GetValue("B");
byte[] binary = _key.GetValueBytes("B");
Assert.IsInstanceOfType(result, typeof(byte[]));
Assert.IsTrue(test.SequenceEqual((byte[])result));
Assert.IsTrue(test.SequenceEqual(binary));
_key.DeleteValue("B");
EnsureValueNamesExist();
}
/// <summary>
/// Sets a value to the REG_QWORD type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, long value, RegValueType type = RegValueType.REG_QWORD)
{
byte[] data = BitConverter.GetBytes(value);
SetValue(name, type, data);
}
/// <summary>
/// Sets a value to the specified type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="type">The optional type for the value.</param>
/// <param name="data">The data for the value.</param>
private void SetValue(string name, RegValueType type, byte[] data)
{
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, dataPtr, data.Length);
Win32Result result = OffregNative.SetValue(_intPtr, name, type, dataPtr, (uint)data.Length);
if (result != Win32Result.ERROR_SUCCESS)
throw new Win32Exception((int)result);
}
finally
{
if (dataPtr != IntPtr.Zero)
Marshal.FreeHGlobal(dataPtr);
}
RefreshMetadata();
}
/// <summary>
/// Sets a value to the REG_BINARY type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, byte[] value, RegValueType type = RegValueType.REG_BINARY)
{
SetValue(name, type, value);
}
/// <summary>
/// Sets a value to the REG_DWORD type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, int value, RegValueType type = RegValueType.REG_DWORD)
{
byte[] data = BitConverter.GetBytes(value);
if (type == RegValueType.REG_DWORD_BIG_ENDIAN)
// Reverse it
Array.Reverse(data);
SetValue(name, type, data);
}
/// <summary>
/// Enumerate a keys values.
/// See http://msdn.microsoft.com/en-us/library/ee210765(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open parent key.</param>
/// <param name="dwIndex">Index of the child to retrieve.</param>
/// <param name="lpValueName">Buffer for the childs name.</param>
/// <param name="lpcchValueName">Size of the childs name buffer.</param>
/// <param name="lpType">Value type.</param>
/// <param name="lpData">Pointer to data buffer.</param>
/// <param name="lpcbData">Size of data buffer.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result EnumValue(IntPtr hKey,
uint dwIndex,
StringBuilder lpValueName,
ref uint lpcchValueName,
out RegValueType lpType,
IntPtr lpData,
ref uint lpcbData)
{
return Is64BitProcess
? EnumValue64(hKey, dwIndex, lpValueName, ref lpcchValueName, out lpType, lpData, ref lpcbData)
: EnumValue32(hKey, dwIndex, lpValueName, ref lpcchValueName, out lpType, lpData, ref lpcbData);
}
private static extern Win32Result SetValue64(
IntPtr hKey,
string lpValueName,
RegValueType dwType,
IntPtr lpData,
uint cbData);
public RegValue(string name, RegValueType type, string value)
{
Name = name;
Type = type;
Value = value;
}
/// <summary>
/// Gets a value under a key.
/// See http://msdn.microsoft.com/en-us/library/ee210767(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open key.</param>
/// <param name="lpSubKey">The name of the subkey under the parent, from which to retrieve the value. May be null.</param>
/// <param name="lpValue">Name of the value to retrieve.</param>
/// <param name="pdwType">The type of the value.</param>
/// <param name="pvData">Unused - set to Intpr.Zero.</param>
/// <param name="pcbData">Unused - set to Intpr.Zero.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result GetValue(IntPtr hKey,
string lpSubKey,
string lpValue,
out RegValueType pdwType,
IntPtr pvData,
IntPtr pcbData)
{
return Is64BitProcess
? GetValue64(hKey, lpSubKey, lpValue, out pdwType, pvData, pcbData)
: GetValue32(hKey, lpSubKey, lpValue, out pdwType, pvData, pcbData);
}
private static extern Win32Result EnumValue64(
IntPtr hKey,
uint dwIndex,
StringBuilder lpValueName,
ref uint lpcchValueName,
out RegValueType lpType,
IntPtr lpData,
ref uint lpcbData);
public RegValue(RegValueType valType, String valName)
{
type = valType;
name = valName;
}
private void WarnDebugForValueType(string valueName, RegValueType parsedType)
{
Debug.WriteLine("WARNING-OFFREGLIB: unknown RegValueType " + parsedType + " converted to Binary in EnumerateValues() at key: " + FullName + ", value: " + valueName);
}
private static extern Win32Result GetValue64(
IntPtr hKey,
string lpSubKey,
string lpValue,
out RegValueType pdwType,
IntPtr pvData,
IntPtr pcbData);
/// <summary>
/// Sets a value to the REG_QWORD type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, long value, RegValueType type = RegValueType.REG_QWORD)
{
byte[] data = BitConverter.GetBytes(value);
SetValue(name, type, data);
}
private void WarnDebugForValueType(string valueName, RegValueType parsedType)
{
Debug.WriteLine("WARNING-OFFREGLIB: unknown RegValueType " + parsedType + " converted to Binary in EnumerateValues() at key: " + FullName + ", value: " + valueName);
}
private static extern Win32Result SetValue64(
IntPtr hKey,
string lpValueName,
RegValueType dwType,
IntPtr lpData,
uint cbData);
/// <summary>
/// Sets a value.
/// See http://msdn.microsoft.com/en-us/library/ee210775(v=vs.85).aspx
/// </summary>
/// <param name="hKey">Handle to an open key.</param>
/// <param name="lpValueName">The name of the value.</param>
/// <param name="dwType">The type of the value.</param>
/// <param name="lpData">The data buffer to save in the value.</param>
/// <param name="cbData">The size of the data buffer.</param>
/// <returns>
/// <see cref="Win32Result" /> of the result. Win32Result.ERROR_SUCCESS indicates success.
/// </returns>
public static Win32Result SetValue(IntPtr hKey,
string lpValueName,
RegValueType dwType,
IntPtr lpData,
uint cbData)
{
return Is64BitProcess
? SetValue64(hKey, lpValueName, dwType, lpData, cbData)
: SetValue32(hKey, lpValueName, dwType, lpData, cbData);
}
/// <summary>
/// Converts some binary data into the form used in the CLR.
/// </summary>
/// <param name="type">The type of data to convert from.</param>
/// <param name="data">The data to convert.</param>
/// <param name="parsedData">The parsed CLR object.</param>
/// <returns>Indication if the parsed data could be parsed correctly as the specified type. If false, data is always a byte[].</returns>
public static bool TryConvertValueDataToObject(RegValueType type, byte[] data, out object parsedData)
{
parsedData = data;
switch (type)
{
case RegValueType.REG_NONE:
// NONE format shouldn't be specified, ever.
return false;
case RegValueType.REG_LINK: // This is a unicode string
case RegValueType.REG_EXPAND_SZ: // This is a unicode string
case RegValueType.REG_SZ:
if (data.Length % 2 != 0)
// UTF-16 strings are always an even number of bytes
return false;
// Remove all the trailing nulls
int toIndex = 0;
while (data.Length > toIndex + 2 && (data[toIndex] != 0 || data[toIndex + 1] != 0))
toIndex += 2;
parsedData = StringEncoding.GetString(data, 0, toIndex);
return true;
case RegValueType.REG_BINARY:
return true;
case RegValueType.REG_DWORD:
if (data.Length != 4)
return false;
parsedData = BitConverter.ToInt32(data, 0);
return true;
case RegValueType.REG_DWORD_BIG_ENDIAN:
if (data.Length != 4)
return false;
Array.Reverse(data);
parsedData = BitConverter.ToInt32(data, 0);
return true;
case RegValueType.REG_MULTI_SZ:
// Get string without the ending null
if (data.Length % 2 != 0)
// Invalid string data, must always be even in length
return false;
if (data.Length == 0)
// A badly formatted list
return false;
if (data.Length == 2 && data[0] == 0 && data[1] == 0)
{
// An empty list is identified by: \0
parsedData = new string[0];
return true;
}
if (data[data.Length - 4] != 0 || data[data.Length - 3] != 0 || data[data.Length - 2] != 0 ||
data[data.Length - 1] != 0)
// Must always end with four nulls
return false;
string s2 = StringEncoding.GetString(data, 0, data.Length - 4);
parsedData = s2.Split(new[] { '\0' });
return true;
case RegValueType.REG_RESOURCE_LIST:
return true;
case RegValueType.REG_FULL_RESOURCE_DESCRIPTOR:
return true;
case RegValueType.REG_RESOURCE_REQUIREMENTS_LIST:
return true;
case RegValueType.REG_QWORD:
if (data.Length != 8)
return false;
parsedData = BitConverter.ToInt64(data, 0);
return true;
default:
throw new ArgumentOutOfRangeException("TryConvertValueDataToObject was given an invalid RegValueType: " + type);
}
}
/// <summary>
/// Delete or create values
/// </summary>
/// <param name="KHdl"></param>
/// <param name="name"></param>
/// <param name="type"></param>
/// <param name="value"></param>
static void setVal(OffregKey KHdl, string name, string type, string value)
{
byte[] bytes;
int num;
RegValueType typeEnum = RegValueType.REG_BINARY; // null not allowed
if (name == "@")
{
name = "";
}
if (value == "-")
{
KHdl.DeleteValue(name);
return;
}
switch (type)
{
case "REG_NONE":
KHdl.SetValueNone(name);
return;
case "REG_SZ":
KHdl.SetValue(name, value, RegValueType.REG_SZ);
return;
case "REG_EXPAND_SZ":
typeEnum = RegValueType.REG_EXPAND_SZ;
break;
case "REG_BINARY":
typeEnum = RegValueType.REG_BINARY;
break;
case "REG_DWORD":
num = Convert.ToInt32(value, 16);
KHdl.SetValue(name, num, RegValueType.REG_DWORD);
return;
case "REG_DWORD_BIG_ENDIAN":
typeEnum = RegValueType.REG_DWORD_BIG_ENDIAN;
break;
case "REG_LINK":
typeEnum = RegValueType.REG_LINK;
break;
case "REG_MULTI_SZ":
typeEnum = RegValueType.REG_MULTI_SZ;
break;
case "REG_RESOURCE_LIST":
typeEnum = RegValueType.REG_RESOURCE_LIST;
break;
case "REG_FULL_RESOURCE_DESCRIPTOR":
typeEnum = RegValueType.REG_FULL_RESOURCE_DESCRIPTOR;
break;
case "REG_RESOURCE_REQUIREMENTS_LIST":
typeEnum = RegValueType.REG_RESOURCE_REQUIREMENTS_LIST;
break;
case "REG_QWORD":
typeEnum = RegValueType.REG_QWORD;
break;
case "REG_QWORD_LITTLE_ENDIAN":
typeEnum = RegValueType.REG_QWORD_LITTLE_ENDIAN;
break;
}
if (managedRegTypes.Contains(type))
{
bytes = value.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray();
KHdl.SetValue(name, bytes, typeEnum);
}
else
{
throw new Exception(string.Format("The type {0} is not known.", type));
}
}
/// <summary>
/// Sets a value to the REG_MULTI_SZ type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="values">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, string[] values, RegValueType type = RegValueType.REG_MULTI_SZ)
{
foreach (string value in values)
if (string.IsNullOrEmpty(value))
throw new ArgumentException("No empty strings allowed");
// A null char for each string, plus a null char at the end
int bytes = 0;
foreach (string value in values)
{
bytes += OffregHelper.StringEncoding.GetByteCount(value) + OffregHelper.SingleCharBytes;
}
bytes += OffregHelper.SingleCharBytes;
byte[] data = new byte[bytes];
int position = 0;
for (int i = 0; i < values.Length; i++)
{
// Save and increment position
position += OffregHelper.StringEncoding.GetBytes(values[i], 0, values[i].Length, data, position) +
OffregHelper.SingleCharBytes;
}
SetValue(name, type, data);
}
/// <summary>
/// Sets a value to the REG_SZ type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, string value, RegValueType type = RegValueType.REG_SZ)
{
// Always leave a trailing null-terminator
byte[] data = new byte[OffregHelper.StringEncoding.GetByteCount(value) + OffregHelper.SingleCharBytes];
OffregHelper.StringEncoding.GetBytes(value, 0, value.Length, data, 0);
SetValue(name, type, data);
}
/// <summary>
/// Sets a value to the REG_BINARY type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="value">The data for the value.</param>
/// <param name="type">The optional type for the value.</param>
public void SetValue(string name, byte[] value, RegValueType type = RegValueType.REG_BINARY)
{
SetValue(name, type, value);
}
private void BinaryTest(RegValueType type, int size)
{
byte[] test = new byte[size];
new Random().NextBytes(test);
_key.SetValue("B", test, type);
Assert.AreEqual(type, _key.GetValueKind("B"));
object result = _key.GetValue("B");
byte[] binary = _key.GetValueBytes("B");
Assert.IsInstanceOfType(result, typeof(byte[]));
Assert.IsTrue(test.SequenceEqual((byte[])result));
Assert.IsTrue(test.SequenceEqual(binary));
_key.DeleteValue("B");
EnsureValueNamesExist();
}
/// <summary>
/// Converts some binary data into the form used in the CLR.
/// </summary>
/// <param name="type">The type of data to convert from.</param>
/// <param name="data">The data to convert.</param>
/// <param name="parsedData">The parsed CLR object.</param>
/// <returns>Indication if the parsed data could be parsed correctly as the specified type. If false, data is always a byte[].</returns>
public static bool TryConvertValueDataToObject(RegValueType type, byte[] data, out object parsedData)
{
parsedData = data;
switch (type)
{
case RegValueType.REG_NONE:
// NONE format shouldn't be specified, ever.
return(false);
case RegValueType.REG_LINK: // This is a unicode string
case RegValueType.REG_EXPAND_SZ: // This is a unicode string
case RegValueType.REG_SZ:
if (data.Length % 2 != 0)
{
// UTF-16 strings are always an even number of bytes
return(false);
}
// Remove all the trailing nulls
int toIndex = 0;
while (data.Length > toIndex + 2 && (data[toIndex] != 0 || data[toIndex + 1] != 0))
{
toIndex += 2;
}
parsedData = StringEncoding.GetString(data, 0, toIndex);
return(true);
case RegValueType.REG_BINARY:
return(true);
case RegValueType.REG_DWORD:
if (data.Length != 4)
{
return(false);
}
parsedData = BitConverter.ToInt32(data, 0);
return(true);
case RegValueType.REG_DWORD_BIG_ENDIAN:
if (data.Length != 4)
{
return(false);
}
Array.Reverse(data);
parsedData = BitConverter.ToInt32(data, 0);
return(true);
case RegValueType.REG_MULTI_SZ:
// Get string without the ending null
if (data.Length % 2 != 0)
{
// Invalid string data, must always be even in length
return(false);
}
if (data.Length == 0)
{
// A badly formatted list
return(false);
}
if (data.Length == 2 && data[0] == 0 && data[1] == 0)
{
// An empty list is identified by: \0
parsedData = new string[0];
return(true);
}
if (data[data.Length - 4] != 0 || data[data.Length - 3] != 0 || data[data.Length - 2] != 0 ||
data[data.Length - 1] != 0)
{
// Must always end with four nulls
return(false);
}
string s2 = StringEncoding.GetString(data, 0, data.Length - 4);
parsedData = s2.Split(new[] { '\0' });
return(true);
case RegValueType.REG_RESOURCE_LIST:
return(true);
case RegValueType.REG_FULL_RESOURCE_DESCRIPTOR:
return(true);
case RegValueType.REG_RESOURCE_REQUIREMENTS_LIST:
return(true);
case RegValueType.REG_QWORD:
if (data.Length != 8)
{
return(false);
}
parsedData = BitConverter.ToInt64(data, 0);
return(true);
default:
throw new ArgumentOutOfRangeException("TryConvertValueDataToObject was given an invalid RegValueType: " + type);
}
}
